~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

transform.translate3d(floatValueForLength(transformOriginX(), borderBoxSize.width()), floatValueForLength(transformOriginY(), borderBoxSize.height()), transformOriginZ());

853

854

unsigned size = transformOperations.size();

855

for (unsigned i = 0; i < size; ++i)

856

transformOperations[i]->apply(transform, borderBoxSize);

857

858

if (applyTransformOrigin)

859

transform.translate3d(-floatValueForLength(transformOriginX(), borderBoxSize.width()), -floatValueForLength(transformOriginY(), borderBoxSize.height()), -transformOriginZ());

860

}

861

862

void RenderStyle::applyTransform(TransformationMatrix& transform, const FloatRect& boundingBox, ApplyTransformOrigin applyOrigin) const

863

{

864

const Vector<RefPtr<TransformOperation> >& transformOperations = rareNonInheritedData->m_transform->m_operations.operations();

865

bool applyTransformOrigin = requireTransformOrigin(transformOperations, applyOrigin);

866

867

float offsetX = transformOriginX().type() == Percent ? boundingBox.x() : 0;

868

float offsetY = transformOriginY().type() == Percent ? boundingBox.y() : 0;

869

870

if (applyTransformOrigin) {

871

transform.translate3d(floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX,

872

floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY,

873

transformOriginZ());

874

}

875

876

unsigned size = transformOperations.size();

877

for (unsigned i = 0; i < size; ++i)

878

transformOperations[i]->apply(transform, boundingBox.size());

879

880

if (applyTransformOrigin) {

881

transform.translate3d(-floatValueForLength(transformOriginX(), boundingBox.width()) - offsetX,

882

-floatValueForLength(transformOriginY(), boundingBox.height()) - offsetY,

883

-transformOriginZ());

884

}

885

}

886

887

void RenderStyle::setPageScaleTransform(float scale)

888

{

889

if (scale == 1)

890

return;

891

TransformOperations transform;

892

transform.operations().append(ScaleTransformOperation::create(scale, scale, ScaleTransformOperation::SCALE));

893

setTransform(transform);

894

setTransformOriginX(Length(0, Fixed));

895

setTransformOriginY(Length(0, Fixed));

896

}

897

898

void RenderStyle::setTextShadow(PassOwnPtr<ShadowData> shadowData, bool add)

899

{

900

ASSERT(!shadowData || (!shadowData->spread() && shadowData->style() == Normal));

901

902

StyleRareInheritedData* rareData = rareInheritedData.access();

903

if (!add) {

904

rareData->textShadow = shadowData;

905

return;

906

}

907

908

shadowData->setNext(rareData->textShadow.release());

909

rareData->textShadow = shadowData;

910

}

911

912

void RenderStyle::setBoxShadow(PassOwnPtr<ShadowData> shadowData, bool add)

913

{

914

StyleRareNonInheritedData* rareData = rareNonInheritedData.access();

915

if (!add) {

916

rareData->m_boxShadow = shadowData;

917

return;

918

}

919

920

shadowData->setNext(rareData->m_boxShadow.release());

921

rareData->m_boxShadow = shadowData;

922

}

923

924

static RoundedRect::Radii calcRadiiFor(const BorderData& border, IntSize size, RenderView* renderView)

925

{

926

return RoundedRect::Radii(

927

IntSize(valueForLength(border.topLeft().width(), size.width(), renderView),

928

valueForLength(border.topLeft().height(), size.height(), renderView)),

929

IntSize(valueForLength(border.topRight().width(), size.width(), renderView),

930

valueForLength(border.topRight().height(), size.height(), renderView)),

931

IntSize(valueForLength(border.bottomLeft().width(), size.width(), renderView),

932

valueForLength(border.bottomLeft().height(), size.height(), renderView)),

933

IntSize(valueForLength(border.bottomRight().width(), size.width(), renderView),

934

valueForLength(border.bottomRight().height(), size.height(), renderView)));

935

}

936

937

static float calcConstraintScaleFor(const IntRect& rect, const RoundedRect::Radii& radii)

938

{

939

// Constrain corner radii using CSS3 rules:

940

// http://www.w3.org/TR/css3-background/#the-border-radius

941

942

float factor = 1;

943

unsigned radiiSum;

944

945

// top

946

radiiSum = static_cast<unsigned>(radii.topLeft().width()) + static_cast<unsigned>(radii.topRight().width()); // Casts to avoid integer overflow.

947

if (radiiSum > static_cast<unsigned>(rect.width()))

948

factor = min(static_cast<float>(rect.width()) / radiiSum, factor);

949

950

// bottom

951

radiiSum = static_cast<unsigned>(radii.bottomLeft().width()) + static_cast<unsigned>(radii.bottomRight().width());

952

if (radiiSum > static_cast<unsigned>(rect.width()))

953

factor = min(static_cast<float>(rect.width()) / radiiSum, factor);

954

955

// left

956

radiiSum = static_cast<unsigned>(radii.topLeft().height()) + static_cast<unsigned>(radii.bottomLeft().height());

957

if (radiiSum > static_cast<unsigned>(rect.height()))

958

factor = min(static_cast<float>(rect.height()) / radiiSum, factor);

959

960

// right

961

radiiSum = static_cast<unsigned>(radii.topRight().height()) + static_cast<unsigned>(radii.bottomRight().height());

962

if (radiiSum > static_cast<unsigned>(rect.height()))

963

factor = min(static_cast<float>(rect.height()) / radiiSum, factor);

964

965

ASSERT(factor <= 1);

966

return factor;

967

}

968

969

StyleImage* RenderStyle::listStyleImage() const { return rareInheritedData->listStyleImage.get(); }

970

void RenderStyle::setListStyleImage(PassRefPtr<StyleImage> v)

971

{

972

if (rareInheritedData->listStyleImage != v)

973

rareInheritedData.access()->listStyleImage = v;

974

}

975

976

Color RenderStyle::color() const { return inherited->color; }

977

Color RenderStyle::visitedLinkColor() const { return inherited->visitedLinkColor; }

978

void RenderStyle::setColor(const Color& v) { SET_VAR(inherited, color, v) };

979

void RenderStyle::setVisitedLinkColor(const Color& v) { SET_VAR(inherited, visitedLinkColor, v) }

980

981

short RenderStyle::horizontalBorderSpacing() const { return inherited->horizontal_border_spacing; }

982

short RenderStyle::verticalBorderSpacing() const { return inherited->vertical_border_spacing; }

983

void RenderStyle::setHorizontalBorderSpacing(short v) { SET_VAR(inherited, horizontal_border_spacing, v) }

984

void RenderStyle::setVerticalBorderSpacing(short v) { SET_VAR(inherited, vertical_border_spacing, v) }

985

986

RoundedRect RenderStyle::getRoundedBorderFor(const LayoutRect& borderRect, RenderView* renderView, bool includeLogicalLeftEdge, bool includeLogicalRightEdge) const

987

{

988

IntRect snappedBorderRect(pixelSnappedIntRect(borderRect));

989

RoundedRect roundedRect(snappedBorderRect);

990

if (hasBorderRadius()) {

991

RoundedRect::Radii radii = calcRadiiFor(surround->border, snappedBorderRect.size(), renderView);

992

radii.scale(calcConstraintScaleFor(snappedBorderRect, radii));

993

roundedRect.includeLogicalEdges(radii, isHorizontalWritingMode(), includeLogicalLeftEdge, includeLogicalRightEdge);

994

}

995

return roundedRect;

996

}

997

998

RoundedRect RenderStyle::getRoundedInnerBorderFor(const LayoutRect& borderRect, bool includeLogicalLeftEdge, bool includeLogicalRightEdge) const

999

{

1000

bool horizontal = isHorizontalWritingMode();

1001

1002

LayoutUnit leftWidth = (!horizontal || includeLogicalLeftEdge) ? borderLeftWidth() : 0;

1003

LayoutUnit rightWidth = (!horizontal || includeLogicalRightEdge) ? borderRightWidth() : 0;

1004

LayoutUnit topWidth = (horizontal || includeLogicalLeftEdge) ? borderTopWidth() : 0;

1005

LayoutUnit bottomWidth = (horizontal || includeLogicalRightEdge) ? borderBottomWidth() : 0;

1006

1007

return getRoundedInnerBorderFor(borderRect, topWidth, bottomWidth, leftWidth, rightWidth, includeLogicalLeftEdge, includeLogicalRightEdge);

1008

}

1009

1010

RoundedRect RenderStyle::getRoundedInnerBorderFor(const LayoutRect& borderRect,

1011

LayoutUnit topWidth, LayoutUnit bottomWidth, LayoutUnit leftWidth, LayoutUnit rightWidth, bool includeLogicalLeftEdge, bool includeLogicalRightEdge) const

1012

{

1013

LayoutRect innerRect(borderRect.x() + leftWidth,

1014

borderRect.y() + topWidth,

1015

borderRect.width() - leftWidth - rightWidth,

1016

borderRect.height() - topWidth - bottomWidth);

1017

1018

RoundedRect roundedRect(pixelSnappedIntRect(innerRect));

1019

1020

if (hasBorderRadius()) {

1021

RoundedRect::Radii radii = getRoundedBorderFor(borderRect).radii();

1022

radii.shrink(topWidth, bottomWidth, leftWidth, rightWidth);

1023

roundedRect.includeLogicalEdges(radii, isHorizontalWritingMode(), includeLogicalLeftEdge, includeLogicalRightEdge);

1024

}

1025

return roundedRect;

1026

}

1027

1028

const CounterDirectiveMap* RenderStyle::counterDirectives() const

1029

{

1030

return rareNonInheritedData->m_counterDirectives.get();

1031

}

1032

1033

CounterDirectiveMap& RenderStyle::accessCounterDirectives()

1034

{

1035

OwnPtr<CounterDirectiveMap>& map = rareNonInheritedData.access()->m_counterDirectives;

1036

if (!map)

1037

map = adoptPtr(new CounterDirectiveMap);

1038

return *map;

1039

}

1040

1041

const CounterDirectives RenderStyle::getCounterDirectives(const AtomicString& identifier) const

1042

{

1043

if (const CounterDirectiveMap* directives = counterDirectives())

1044

return directives->get(identifier);

1045

return CounterDirectives();

1046

}

1047

1048

const AtomicString& RenderStyle::hyphenString() const

1049

{

1050

ASSERT(hyphens() != HyphensNone);

1051

1052

const AtomicString& hyphenationString = rareInheritedData.get()->hyphenationString;

1053

if (!hyphenationString.isNull())

1054

return hyphenationString;

1055

1056

// FIXME: This should depend on locale.

1057

DEFINE_STATIC_LOCAL(AtomicString, hyphenMinusString, (&hyphenMinus, 1));

1058

DEFINE_STATIC_LOCAL(AtomicString, hyphenString, (&hyphen, 1));

1059

return font().primaryFontHasGlyphForCharacter(hyphen) ? hyphenString : hyphenMinusString;

1060

}

1061

1062

const AtomicString& RenderStyle::textEmphasisMarkString() const

1063

{

1064

switch (textEmphasisMark()) {

1065

case TextEmphasisMarkNone:

1066

return nullAtom;

1067

case TextEmphasisMarkCustom:

1068

return textEmphasisCustomMark();

1069

case TextEmphasisMarkDot: {

1070

DEFINE_STATIC_LOCAL(AtomicString, filledDotString, (&bullet, 1));

1071

DEFINE_STATIC_LOCAL(AtomicString, openDotString, (&whiteBullet, 1));

1072

return textEmphasisFill() == TextEmphasisFillFilled ? filledDotString : openDotString;

1073

}

1074

case TextEmphasisMarkCircle: {

1075

DEFINE_STATIC_LOCAL(AtomicString, filledCircleString, (&blackCircle, 1));

1076

DEFINE_STATIC_LOCAL(AtomicString, openCircleString, (&whiteCircle, 1));

1077

return textEmphasisFill() == TextEmphasisFillFilled ? filledCircleString : openCircleString;

1078

}

1079

case TextEmphasisMarkDoubleCircle: {

1080

DEFINE_STATIC_LOCAL(AtomicString, filledDoubleCircleString, (&fisheye, 1));

1081

DEFINE_STATIC_LOCAL(AtomicString, openDoubleCircleString, (&bullseye, 1));

1082

return textEmphasisFill() == TextEmphasisFillFilled ? filledDoubleCircleString : openDoubleCircleString;

1083

}

1084

case TextEmphasisMarkTriangle: {

1085

DEFINE_STATIC_LOCAL(AtomicString, filledTriangleString, (&blackUpPointingTriangle, 1));

1086

DEFINE_STATIC_LOCAL(AtomicString, openTriangleString, (&whiteUpPointingTriangle, 1));

1087

return textEmphasisFill() == TextEmphasisFillFilled ? filledTriangleString : openTriangleString;

1088

}

1089

case TextEmphasisMarkSesame: {

1090

DEFINE_STATIC_LOCAL(AtomicString, filledSesameString, (&sesameDot, 1));

1091

DEFINE_STATIC_LOCAL(AtomicString, openSesameString, (&whiteSesameDot, 1));

1092

return textEmphasisFill() == TextEmphasisFillFilled ? filledSesameString : openSesameString;

1093

}

1094

case TextEmphasisMarkAuto:

1095

ASSERT_NOT_REACHED();

1096

return nullAtom;

1097

}

1098

1099

ASSERT_NOT_REACHED();

1100

return nullAtom;

1101

}

1102

1103

#if ENABLE(DASHBOARD_SUPPORT)

1104

const Vector<StyleDashboardRegion>& RenderStyle::initialDashboardRegions()

1105

{

1106

DEFINE_STATIC_LOCAL(Vector<StyleDashboardRegion>, emptyList, ());

1107

return emptyList;

1108

}

1109

1110

const Vector<StyleDashboardRegion>& RenderStyle::noneDashboardRegions()

1111

{

1112

DEFINE_STATIC_LOCAL(Vector<StyleDashboardRegion>, noneList, ());

1113

static bool noneListInitialized = false;

1114

1115

if (!noneListInitialized) {

1116

StyleDashboardRegion region;

1117

region.label = "";

1118

region.offset.m_top = Length();

1119

region.offset.m_right = Length();

1120

region.offset.m_bottom = Length();

1121

region.offset.m_left = Length();

1122

region.type = StyleDashboardRegion::None;

1123

noneList.append(region);

1124

noneListInitialized = true;

1125

}

1126

return noneList;

1127

}

1128

#endif

1129

1130

void RenderStyle::adjustAnimations()

1131

{

1132

AnimationList* animationList = rareNonInheritedData->m_animations.get();

1133

if (!animationList)

1134

return;

1135

1136

// Get rid of empty animations and anything beyond them

1137

for (size_t i = 0; i < animationList->size(); ++i) {

1138

if (animationList->animation(i)->isEmpty()) {

1139

animationList->resize(i);

1140

break;

1141

}

1142

}

1143

1144

if (animationList->isEmpty()) {

1145

clearAnimations();

1146

return;

1147

}

1148

1149

// Repeat patterns into layers that don't have some properties set.

1150

animationList->fillUnsetProperties();

1151

}

1152

1153

void RenderStyle::adjustTransitions()

1154

{

1155

AnimationList* transitionList = rareNonInheritedData->m_transitions.get();

1156

if (!transitionList)

1157

return;

1158

1159

// Get rid of empty transitions and anything beyond them

1160

for (size_t i = 0; i < transitionList->size(); ++i) {

1161

if (transitionList->animation(i)->isEmpty()) {

1162

transitionList->resize(i);

1163

break;

1164

}

1165

}

1166

1167

if (transitionList->isEmpty()) {

1168

clearTransitions();

1169

return;

1170

}

1171

1172

// Repeat patterns into layers that don't have some properties set.

1173

transitionList->fillUnsetProperties();

1174

1175

// Make sure there are no duplicate properties. This is an O(n^2) algorithm

1176

// but the lists tend to be very short, so it is probably ok

1177

for (size_t i = 0; i < transitionList->size(); ++i) {

1178

for (size_t j = i+1; j < transitionList->size(); ++j) {

1179

if (transitionList->animation(i)->property() == transitionList->animation(j)->property()) {

1180

// toss i

1181

transitionList->remove(i);

1182

j = i;

1183

}

1184

}

1185

}

1186

}

1187

1188

AnimationList* RenderStyle::accessAnimations()

1189

{

1190

if (!rareNonInheritedData.access()->m_animations)

1191

rareNonInheritedData.access()->m_animations = adoptPtr(new AnimationList());

1192

return rareNonInheritedData->m_animations.get();

1193

}

1194

1195

AnimationList* RenderStyle::accessTransitions()

1196

{

1197

if (!rareNonInheritedData.access()->m_transitions)

1198

rareNonInheritedData.access()->m_transitions = adoptPtr(new AnimationList());

1199

return rareNonInheritedData->m_transitions.get();

1200

}

1201

1202

const Animation* RenderStyle::transitionForProperty(CSSPropertyID property) const

1203

{

1204

if (transitions()) {

1205

for (size_t i = 0; i < transitions()->size(); ++i) {

1206

const Animation* p = transitions()->animation(i);

1207

if (p->animationMode() == Animation::AnimateAll || p->property() == property) {

1208

return p;

1209

}

1210

}

1211

}

1212

return 0;

1213

}

1214

1215

const Font& RenderStyle::font() const { return inherited->font; }

1216

const FontMetrics& RenderStyle::fontMetrics() const { return inherited->font.fontMetrics(); }

1217

const FontDescription& RenderStyle::fontDescription() const { return inherited->font.fontDescription(); }

1218

float RenderStyle::specifiedFontSize() const { return fontDescription().specifiedSize(); }

1219

float RenderStyle::computedFontSize() const { return fontDescription().computedSize(); }

1220

int RenderStyle::fontSize() const { return inherited->font.pixelSize(); }

1221

1222

int RenderStyle::wordSpacing() const { return inherited->font.wordSpacing(); }

1223

int RenderStyle::letterSpacing() const { return inherited->font.letterSpacing(); }

1224

1225

bool RenderStyle::setFontDescription(const FontDescription& v)

1226

{

1227

if (inherited->font.fontDescription() != v) {

1228

inherited.access()->font = Font(v, inherited->font.letterSpacing(), inherited->font.wordSpacing());

1229

return true;

1230

}

1231

return false;

1232

}

1233

1234

Length RenderStyle::specifiedLineHeight() const { return inherited->line_height; }

1235

Length RenderStyle::lineHeight() const

1236

{

1237

const Length& lh = inherited->line_height;

1238

#if ENABLE(TEXT_AUTOSIZING)

1239

// Unlike fontDescription().computedSize() and hence fontSize(), this is

1240

// recalculated on demand as we only store the specified line height.

1241

// FIXME: Should consider scaling the fixed part of any calc expressions

1242

// too, though this involves messily poking into CalcExpressionLength.

1243

float multiplier = textAutosizingMultiplier();

1244

if (multiplier > 1 && lh.isFixed())

1245

return Length(TextAutosizer::computeAutosizedFontSize(lh.value(), multiplier), Fixed);

1246

#endif

1247

return lh;

1248

}

1249

void RenderStyle::setLineHeight(Length specifiedLineHeight) { SET_VAR(inherited, line_height, specifiedLineHeight); }

1250

1251

int RenderStyle::computedLineHeight(RenderView* renderView) const

1252

{

1253

const Length& lh = lineHeight();

1254

1255

// Negative value means the line height is not set. Use the font's built-in spacing.

1256

if (lh.isNegative())

1257

return fontMetrics().lineSpacing();

1258

1259

if (lh.isPercent())

1260

return minimumValueForLength(lh, fontSize());

1261

1262

if (lh.isViewportPercentage())

1263

return valueForLength(lh, 0, renderView);

1264

1265

return lh.value();

1266

}

1267

1268

void RenderStyle::setWordSpacing(int v) { inherited.access()->font.setWordSpacing(v); }

1269

void RenderStyle::setLetterSpacing(int v) { inherited.access()->font.setLetterSpacing(v); }

1270

1271

void RenderStyle::setFontSize(float size)

1272

{

1273

// size must be specifiedSize if Text Autosizing is enabled, but computedSize if text

1274

// zoom is enabled (if neither is enabled it's irrelevant as they're probably the same).

1275

1276

FontSelector* currentFontSelector = font().fontSelector();

1277

FontDescription desc(fontDescription());

1278

desc.setSpecifiedSize(size);

1279

desc.setComputedSize(size);

1280

1281

#if ENABLE(TEXT_AUTOSIZING)

1282

float multiplier = textAutosizingMultiplier();

1283

if (multiplier > 1) {

1284

desc.setComputedSize(TextAutosizer::computeAutosizedFontSize(size, multiplier));

1285

}

1286

#endif

1287

1288

setFontDescription(desc);

1289

font().update(currentFontSelector);

1290

}

1291

1292

void RenderStyle::getShadowExtent(const ShadowData* shadow, LayoutUnit &top, LayoutUnit &right, LayoutUnit &bottom, LayoutUnit &left) const

1293

{

1294

top = 0;

1295

right = 0;

1296

bottom = 0;

1297

left = 0;

1298

1299

for ( ; shadow; shadow = shadow->next()) {

1300

if (shadow->style() == Inset)

1301

continue;

1302

int blurAndSpread = shadow->blur() + shadow->spread();

1303

1304

top = min<LayoutUnit>(top, shadow->y() - blurAndSpread);

1305

right = max<LayoutUnit>(right, shadow->x() + blurAndSpread);

1306

bottom = max<LayoutUnit>(bottom, shadow->y() + blurAndSpread);

1307

left = min<LayoutUnit>(left, shadow->x() - blurAndSpread);

1308

}

1309

}

1310

1311

LayoutBoxExtent RenderStyle::getShadowInsetExtent(const ShadowData* shadow) const

1312

{

1313

LayoutUnit top = 0;

1314

LayoutUnit right = 0;

1315

LayoutUnit bottom = 0;

1316

LayoutUnit left = 0;

1317

1318

for ( ; shadow; shadow = shadow->next()) {

1319

if (shadow->style() == Normal)

1320

continue;

1321

int blurAndSpread = shadow->blur() + shadow->spread();

1322

top = max<LayoutUnit>(top, shadow->y() + blurAndSpread);

1323

right = min<LayoutUnit>(right, shadow->x() - blurAndSpread);

1324

bottom = min<LayoutUnit>(bottom, shadow->y() - blurAndSpread);

1325

left = max<LayoutUnit>(left, shadow->x() + blurAndSpread);

1326

}

1327

1328

return LayoutBoxExtent(top, right, bottom, left);

1329

}

1330

1331

void RenderStyle::getShadowHorizontalExtent(const ShadowData* shadow, LayoutUnit &left, LayoutUnit &right) const

1332

{

1333

left = 0;

1334

right = 0;

1335

1336

for ( ; shadow; shadow = shadow->next()) {

1337

if (shadow->style() == Inset)

1338

continue;

1339

int blurAndSpread = shadow->blur() + shadow->spread();

1340

1341

left = min<LayoutUnit>(left, shadow->x() - blurAndSpread);

1342

right = max<LayoutUnit>(right, shadow->x() + blurAndSpread);

1343

}

1344

}

1345

1346

void RenderStyle::getShadowVerticalExtent(const ShadowData* shadow, LayoutUnit &top, LayoutUnit &bottom) const

1347

{

1348

top = 0;

1349

bottom = 0;

1350

1351

for ( ; shadow; shadow = shadow->next()) {

1352

if (shadow->style() == Inset)

1353

continue;

1354

int blurAndSpread = shadow->blur() + shadow->spread();

1355

1356

top = min<LayoutUnit>(top, shadow->y() - blurAndSpread);

1357

bottom = max<LayoutUnit>(bottom, shadow->y() + blurAndSpread);

1358

}

1359

}

1360

1361

Color RenderStyle::colorIncludingFallback(int colorProperty, bool visitedLink) const

1362

{

1363

Color result;

1364

EBorderStyle borderStyle = BNONE;

1365

switch (colorProperty) {

1366

case CSSPropertyBackgroundColor:

1367

return visitedLink ? visitedLinkBackgroundColor() : backgroundColor(); // Background color doesn't fall back.

1368

case CSSPropertyBorderLeftColor:

1369

result = visitedLink ? visitedLinkBorderLeftColor() : borderLeftColor();

1370

borderStyle = borderLeftStyle();

1371

break;

1372

case CSSPropertyBorderRightColor:

1373

result = visitedLink ? visitedLinkBorderRightColor() : borderRightColor();

1374

borderStyle = borderRightStyle();

1375

break;

1376

case CSSPropertyBorderTopColor:

1377

result = visitedLink ? visitedLinkBorderTopColor() : borderTopColor();

1378

borderStyle = borderTopStyle();

1379

break;

1380

case CSSPropertyBorderBottomColor:

1381

result = visitedLink ? visitedLinkBorderBottomColor() : borderBottomColor();

1382

borderStyle = borderBottomStyle();

1383

break;

1384

case CSSPropertyColor:

1385

result = visitedLink ? visitedLinkColor() : color();

1386

break;

1387

case CSSPropertyOutlineColor:

1388

result = visitedLink ? visitedLinkOutlineColor() : outlineColor();

1389

break;

1390

case CSSPropertyWebkitColumnRuleColor:

1391

result = visitedLink ? visitedLinkColumnRuleColor() : columnRuleColor();

1392

break;

1393

case CSSPropertyWebkitTextEmphasisColor:

1394

result = visitedLink ? visitedLinkTextEmphasisColor() : textEmphasisColor();

1395

break;

1396

case CSSPropertyWebkitTextFillColor:

1397

result = visitedLink ? visitedLinkTextFillColor() : textFillColor();

1398

break;

1399

case CSSPropertyWebkitTextStrokeColor:

1400

result = visitedLink ? visitedLinkTextStrokeColor() : textStrokeColor();

1401

break;

1402

default:

1403

ASSERT_NOT_REACHED();

1404

break;

1405

}

1406

1407

if (!result.isValid()) {

1408

if (!visitedLink && (borderStyle == INSET || borderStyle == OUTSET || borderStyle == RIDGE || borderStyle == GROOVE))

1409

result.setRGB(238, 238, 238);

1410

else

1411

result = visitedLink ? visitedLinkColor() : color();

1412

}

1413

return result;

1414

}

1415

1416

Color RenderStyle::visitedDependentColor(int colorProperty) const

1417

{

1418

Color unvisitedColor = colorIncludingFallback(colorProperty, false);

1419

if (insideLink() != InsideVisitedLink)

1420

return unvisitedColor;

1421

1422

Color visitedColor = colorIncludingFallback(colorProperty, true);

1423

1424

// FIXME: Technically someone could explicitly specify the color transparent, but for now we'll just

1425

// assume that if the background color is transparent that it wasn't set. Note that it's weird that

1426

// we're returning unvisited info for a visited link, but given our restriction that the alpha values

1427

// have to match, it makes more sense to return the unvisited background color if specified than it

1428

// does to return black. This behavior matches what Firefox 4 does as well.

1429

if (colorProperty == CSSPropertyBackgroundColor && visitedColor == Color::transparent)

1430

return unvisitedColor;

1431

1432

// Take the alpha from the unvisited color, but get the RGB values from the visited color.

1433

return Color(visitedColor.red(), visitedColor.green(), visitedColor.blue(), unvisitedColor.alpha());

1434

}

1435

1436

const BorderValue& RenderStyle::borderBefore() const

1437

{

1438

switch (writingMode()) {

1439

case TopToBottomWritingMode:

1440

return borderTop();

1441

case BottomToTopWritingMode:

1442

return borderBottom();

1443

case LeftToRightWritingMode:

1444

return borderLeft();

1445

case RightToLeftWritingMode:

1446

return borderRight();

1447

}

1448

ASSERT_NOT_REACHED();

1449

return borderTop();

1450

}

1451

1452

const BorderValue& RenderStyle::borderAfter() const

1453

{

1454

switch (writingMode()) {

1455

case TopToBottomWritingMode:

1456

return borderBottom();

1457

case BottomToTopWritingMode:

1458

return borderTop();

1459

case LeftToRightWritingMode:

1460

return borderRight();

1461

case RightToLeftWritingMode:

1462

return borderLeft();

1463

}

1464

ASSERT_NOT_REACHED();

1465

return borderBottom();

1466

}

1467

1468

const BorderValue& RenderStyle::borderStart() const

1469

{

1470

if (isHorizontalWritingMode())

1471

return isLeftToRightDirection() ? borderLeft() : borderRight();

1472

return isLeftToRightDirection() ? borderTop() : borderBottom();

1473

}

1474

1475

const BorderValue& RenderStyle::borderEnd() const

1476

{

1477

if (isHorizontalWritingMode())

1478

return isLeftToRightDirection() ? borderRight() : borderLeft();

1479

return isLeftToRightDirection() ? borderBottom() : borderTop();

1480

}

1481

1482

unsigned short RenderStyle::borderBeforeWidth() const

1483

{

1484

switch (writingMode()) {

1485

case TopToBottomWritingMode:

1486

return borderTopWidth();

1487

case BottomToTopWritingMode:

1488

return borderBottomWidth();

1489

case LeftToRightWritingMode:

1490

return borderLeftWidth();

1491

case RightToLeftWritingMode:

1492

return borderRightWidth();

1493

}

1494

ASSERT_NOT_REACHED();

1495

return borderTopWidth();

1496

}

1497

1498

unsigned short RenderStyle::borderAfterWidth() const

1499

{

1500

switch (writingMode()) {

1501

case TopToBottomWritingMode:

1502

return borderBottomWidth();

1503

case BottomToTopWritingMode:

1504

return borderTopWidth();

1505

case LeftToRightWritingMode:

1506

return borderRightWidth();

1507

case RightToLeftWritingMode:

1508

return borderLeftWidth();

1509

}

1510

ASSERT_NOT_REACHED();

1511

return borderBottomWidth();

1512

}

1513

1514

unsigned short RenderStyle::borderStartWidth() const

1515

{

1516

if (isHorizontalWritingMode())

1517

return isLeftToRightDirection() ? borderLeftWidth() : borderRightWidth();

1518

return isLeftToRightDirection() ? borderTopWidth() : borderBottomWidth();

1519

}

1520

1521

unsigned short RenderStyle::borderEndWidth() const

1522

{

1523

if (isHorizontalWritingMode())

1524

return isLeftToRightDirection() ? borderRightWidth() : borderLeftWidth();

1525

return isLeftToRightDirection() ? borderBottomWidth() : borderTopWidth();

1526

}

1527

1528

void RenderStyle::setMarginStart(Length margin)

1529

{

1530

if (isHorizontalWritingMode()) {

1531

if (isLeftToRightDirection())

1532

setMarginLeft(margin);

1533

else

1534

setMarginRight(margin);

1535

} else {

1536

if (isLeftToRightDirection())

1537

setMarginTop(margin);

1538

else

1539

setMarginBottom(margin);

1540

}

1541

}

1542

1543

void RenderStyle::setMarginEnd(Length margin)

1544

{

1545

if (isHorizontalWritingMode()) {

1546

if (isLeftToRightDirection())

1547

setMarginRight(margin);

1548

else

1549

setMarginLeft(margin);

1550

} else {

1551

if (isLeftToRightDirection())

1552

setMarginBottom(margin);

1553

else

1554

setMarginTop(margin);

1555

}

1556

}

1557

1558

TextEmphasisMark RenderStyle::textEmphasisMark() const

1559

{

1560

TextEmphasisMark mark = static_cast<TextEmphasisMark>(rareInheritedData->textEmphasisMark);

1561

if (mark != TextEmphasisMarkAuto)

1562

return mark;

1563

1564

if (isHorizontalWritingMode())

1565

return TextEmphasisMarkDot;

1566

1567

return TextEmphasisMarkSesame;

1568

}

1569

1570

#if ENABLE(TOUCH_EVENTS)

1571

Color RenderStyle::initialTapHighlightColor()

1572

{

1573

return RenderTheme::tapHighlightColor();

1574

}

1575

#endif

1576

1577

LayoutBoxExtent RenderStyle::imageOutsets(const NinePieceImage& image) const

1578

{

1579

return LayoutBoxExtent(NinePieceImage::computeOutset(image.outset().top(), borderTopWidth()),

1580

NinePieceImage::computeOutset(image.outset().right(), borderRightWidth()),

1581

NinePieceImage::computeOutset(image.outset().bottom(), borderBottomWidth()),

1582

NinePieceImage::computeOutset(image.outset().left(), borderLeftWidth()));

1583

}

1584

1585

void RenderStyle::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const

1586

{

1587

MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);

1588

info.addMember(m_box);

1589

info.addMember(visual);

1590

// FIXME: m_background contains RefPtr<StyleImage> that might need to be instrumented.

1591

info.addMember(m_background);

1592

// FIXME: surrond contains some fields e.g. BorderData that might need to be instrumented.

1593

info.addMember(surround);

1594

info.addMember(rareNonInheritedData);

1595

info.addMember(rareInheritedData);

1596

// FIXME: inherited contains StyleImage and Font fields that might need to be instrumented.

1597

info.addMember(inherited);

1598

info.addMember(m_cachedPseudoStyles);

1599

#if ENABLE(SVG)

1600

info.addMember(m_svgStyle);

1601

#endif

1602

}

1603

1604

} // namespace WebCore

Older »