Blame - Source/core/css/CSSComputedStyleDeclaration.cpp - fp2-dev/platform/external/chromium_org/third_party/WebKit

2013-07-10 11:41:44 +0100

[diff] [blame]

637

}

638

if (l.isViewportPercentage())

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

639

return zoomAdjustedPixelValue(valueForLength(l, 0, renderView), style);

640

if (l.isAuto()) {

641

// FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.

642

// In other words if left is auto and right is not auto, then left's computed value is negative right().

643

// So we should get the opposite length unit and see if it is auto.

644

return cssValuePool().createValue(l);

645

}

646

647

return zoomAdjustedPixelValueForLength(l, style);

648

}

649

650

PassRefPtr<CSSPrimitiveValue> CSSComputedStyleDeclaration::currentColorOrValidColor(RenderStyle* style, const Color& color) const

651

{

652

// This function does NOT look at visited information, so that computed style doesn't expose that.

653

if (!color.isValid())

654

return cssValuePool().createColorValue(style->color().rgb());

655

return cssValuePool().createColorValue(color.rgb());

656

}

657

658

static PassRefPtr<CSSValueList> getBorderRadiusCornerValues(LengthSize radius, const RenderStyle* style, RenderView* renderView)

659

{

660

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

661

if (radius.width().type() == Percent)

662

list->append(cssValuePool().createValue(radius.width().percent(), CSSPrimitiveValue::CSS_PERCENTAGE));

663

else

664

list->append(zoomAdjustedPixelValue(valueForLength(radius.width(), 0, renderView), style));

665

if (radius.height().type() == Percent)

666

list->append(cssValuePool().createValue(radius.height().percent(), CSSPrimitiveValue::CSS_PERCENTAGE));

667

else

668

list->append(zoomAdjustedPixelValue(valueForLength(radius.height(), 0, renderView), style));

669

return list.release();

670

}

671

672

static PassRefPtr<CSSValue> getBorderRadiusCornerValue(LengthSize radius, const RenderStyle* style, RenderView* renderView)

673

{

674

if (radius.width() == radius.height()) {

675

if (radius.width().type() == Percent)

676

return cssValuePool().createValue(radius.width().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);

677

return zoomAdjustedPixelValue(valueForLength(radius.width(), 0, renderView), style);

678

}

679

return getBorderRadiusCornerValues(radius, style, renderView);

680

}

681

682

static PassRefPtr<CSSValueList> getBorderRadiusShorthandValue(const RenderStyle* style, RenderView* renderView)

683

{

684

RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();

685

bool showHorizontalBottomLeft = style->borderTopRightRadius().width() != style->borderBottomLeftRadius().width();

686

bool showHorizontalBottomRight = style->borderBottomRightRadius().width() != style->borderTopLeftRadius().width();

687

bool showHorizontalTopRight = style->borderTopRightRadius().width() != style->borderTopLeftRadius().width();

688

689

bool showVerticalBottomLeft = style->borderTopRightRadius().height() != style->borderBottomLeftRadius().height();

690

bool showVerticalBottomRight = (style->borderBottomRightRadius().height() != style->borderTopLeftRadius().height()) || showVerticalBottomLeft;

691

bool showVerticalTopRight = (style->borderTopRightRadius().height() != style->borderTopLeftRadius().height()) || showVerticalBottomRight;

692

bool showVerticalTopLeft = (style->borderTopLeftRadius().width() != style->borderTopLeftRadius().height());

693

694

RefPtr<CSSValueList> topLeftRadius = getBorderRadiusCornerValues(style->borderTopLeftRadius(), style, renderView);

695

RefPtr<CSSValueList> topRightRadius = getBorderRadiusCornerValues(style->borderTopRightRadius(), style, renderView);

696

RefPtr<CSSValueList> bottomRightRadius = getBorderRadiusCornerValues(style->borderBottomRightRadius(), style, renderView);

697

RefPtr<CSSValueList> bottomLeftRadius = getBorderRadiusCornerValues(style->borderBottomLeftRadius(), style, renderView);

698

699

RefPtr<CSSValueList> horizontalRadii = CSSValueList::createSpaceSeparated();

700

horizontalRadii->append(topLeftRadius->item(0));

701

if (showHorizontalTopRight)

702

horizontalRadii->append(topRightRadius->item(0));

703

if (showHorizontalBottomRight)

704

horizontalRadii->append(bottomRightRadius->item(0));

705

if (showHorizontalBottomLeft)

706

horizontalRadii->append(bottomLeftRadius->item(0));

707

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

708

list->append(horizontalRadii.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

709

710

if (showVerticalTopLeft) {

711

RefPtr<CSSValueList> verticalRadii = CSSValueList::createSpaceSeparated();

712

verticalRadii->append(topLeftRadius->item(1));

713

if (showVerticalTopRight)

714

verticalRadii->append(topRightRadius->item(1));

715

if (showVerticalBottomRight)

716

verticalRadii->append(bottomRightRadius->item(1));

717

if (showVerticalBottomLeft)

718

verticalRadii->append(bottomLeftRadius->item(1));

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

719

list->append(verticalRadii.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

720

}

721

return list.release();

722

}

723

724

static LayoutRect sizingBox(RenderObject* renderer)

725

{

726

if (!renderer->isBox())

727

return LayoutRect();

728

729

RenderBox* box = toRenderBox(renderer);

730

return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();

731

}

732

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

733

static PassRefPtr<CSSTransformValue> matrixTransformValue(const TransformationMatrix& transform, const RenderStyle* style)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

734

{

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

735

RefPtr<CSSTransformValue> transformValue;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

736

if (transform.isAffine()) {

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

737

transformValue = CSSTransformValue::create(CSSTransformValue::MatrixTransformOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

738

739

transformValue->append(cssValuePool().createValue(transform.a(), CSSPrimitiveValue::CSS_NUMBER));

740

transformValue->append(cssValuePool().createValue(transform.b(), CSSPrimitiveValue::CSS_NUMBER));

741

transformValue->append(cssValuePool().createValue(transform.c(), CSSPrimitiveValue::CSS_NUMBER));

742

transformValue->append(cssValuePool().createValue(transform.d(), CSSPrimitiveValue::CSS_NUMBER));

743

transformValue->append(zoomAdjustedNumberValue(transform.e(), style));

744

transformValue->append(zoomAdjustedNumberValue(transform.f(), style));

745

} else {

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

746

transformValue = CSSTransformValue::create(CSSTransformValue::Matrix3DTransformOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

747

748

transformValue->append(cssValuePool().createValue(transform.m11(), CSSPrimitiveValue::CSS_NUMBER));

749

transformValue->append(cssValuePool().createValue(transform.m12(), CSSPrimitiveValue::CSS_NUMBER));

750

transformValue->append(cssValuePool().createValue(transform.m13(), CSSPrimitiveValue::CSS_NUMBER));

751

transformValue->append(cssValuePool().createValue(transform.m14(), CSSPrimitiveValue::CSS_NUMBER));

752

753

transformValue->append(cssValuePool().createValue(transform.m21(), CSSPrimitiveValue::CSS_NUMBER));

754

transformValue->append(cssValuePool().createValue(transform.m22(), CSSPrimitiveValue::CSS_NUMBER));

755

transformValue->append(cssValuePool().createValue(transform.m23(), CSSPrimitiveValue::CSS_NUMBER));

756

transformValue->append(cssValuePool().createValue(transform.m24(), CSSPrimitiveValue::CSS_NUMBER));

757

758

transformValue->append(cssValuePool().createValue(transform.m31(), CSSPrimitiveValue::CSS_NUMBER));

759

transformValue->append(cssValuePool().createValue(transform.m32(), CSSPrimitiveValue::CSS_NUMBER));

760

transformValue->append(cssValuePool().createValue(transform.m33(), CSSPrimitiveValue::CSS_NUMBER));

761

transformValue->append(cssValuePool().createValue(transform.m34(), CSSPrimitiveValue::CSS_NUMBER));

762

763

transformValue->append(zoomAdjustedNumberValue(transform.m41(), style));

764

transformValue->append(zoomAdjustedNumberValue(transform.m42(), style));

765

transformValue->append(zoomAdjustedNumberValue(transform.m43(), style));

766

transformValue->append(cssValuePool().createValue(transform.m44(), CSSPrimitiveValue::CSS_NUMBER));

767

}

768

769

return transformValue.release();

770

}

771

772

static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)

773

{

774

if (!renderer || !renderer->hasTransform() || !style->hasTransform())

775

return cssValuePool().createIdentifierValue(CSSValueNone);

776

777

IntRect box;

778

if (renderer->isBox())

779

box = pixelSnappedIntRect(toRenderBox(renderer)->borderBoxRect());

780

781

TransformationMatrix transform;

782

style->applyTransform(transform, box.size(), RenderStyle::ExcludeTransformOrigin);

783

784

// FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)

785

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

786

list->append(matrixTransformValue(transform, style));

787

788

return list.release();

789

}

790

791

static PassRefPtr<CSSValue> valueForCustomFilterArrayParameter(const CustomFilterArrayParameter* arrayParameter)

792

{

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

793

RefPtr<CSSArrayFunctionValue> arrayParameterValue = CSSArrayFunctionValue::create();

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

794

for (unsigned i = 0, size = arrayParameter->size(); i < size; ++i)

795

arrayParameterValue->append(cssValuePool().createValue(arrayParameter->valueAt(i), CSSPrimitiveValue::CSS_NUMBER));

796

return arrayParameterValue.release();

797

}

798

799

static PassRefPtr<CSSValue> valueForCustomFilterNumberParameter(const CustomFilterNumberParameter* numberParameter)

800

{

801

RefPtr<CSSValueList> numberParameterValue = CSSValueList::createSpaceSeparated();

802

for (unsigned i = 0; i < numberParameter->size(); ++i)

803

numberParameterValue->append(cssValuePool().createValue(numberParameter->valueAt(i), CSSPrimitiveValue::CSS_NUMBER));

804

return numberParameterValue.release();

805

}

806

807

static PassRefPtr<CSSValue> valueForCustomFilterTransformParameter(const RenderObject* renderer, const RenderStyle* style, const CustomFilterTransformParameter* transformParameter)

808

{

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

809

IntSize size;

810

if (renderer && renderer->isBox())

811

size = pixelSnappedIntRect(toRenderBox(renderer)->borderBoxRect()).size();

812

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

813

TransformationMatrix transform;

814

transformParameter->applyTransform(transform, size);

815

// FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)

816

return matrixTransformValue(transform, style);

817

}

818

819

static PassRefPtr<CSSValue> valueForCustomFilterParameter(const RenderObject* renderer, const RenderStyle* style, const CustomFilterParameter* parameter)

820

{

821

// FIXME: Add here computed style for the other types: boolean, transform, matrix, texture.

822

ASSERT(parameter);

823

switch (parameter->parameterType()) {

824

case CustomFilterParameter::ARRAY:

825

return valueForCustomFilterArrayParameter(static_cast<const CustomFilterArrayParameter*>(parameter));

826

case CustomFilterParameter::NUMBER:

827

return valueForCustomFilterNumberParameter(static_cast<const CustomFilterNumberParameter*>(parameter));

828

case CustomFilterParameter::TRANSFORM:

829

return valueForCustomFilterTransformParameter(renderer, style, static_cast<const CustomFilterTransformParameter*>(parameter));

830

}

831

832

ASSERT_NOT_REACHED();

return 0;

}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::valueForFilter(const RenderObject* renderer, const RenderStyle* style) const

837

{

838

if (style->filter().operations().isEmpty())

839

return cssValuePool().createIdentifierValue(CSSValueNone);

840

841

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

842

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

843

RefPtr<CSSFilterValue> filterValue;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

844

845

Vector<RefPtr<FilterOperation> >::const_iterator end = style->filter().operations().end();

846

for (Vector<RefPtr<FilterOperation> >::const_iterator it = style->filter().operations().begin(); it != end; ++it) {

847

FilterOperation* filterOperation = (*it).get();

848

switch (filterOperation->getOperationType()) {

849

case FilterOperation::REFERENCE: {

850

ReferenceFilterOperation* referenceOperation = static_cast<ReferenceFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

851

filterValue = CSSFilterValue::create(CSSFilterValue::ReferenceFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

852

filterValue->append(cssValuePool().createValue(referenceOperation->url(), CSSPrimitiveValue::CSS_STRING));

853

break;

854

}

855

case FilterOperation::GRAYSCALE: {

856

BasicColorMatrixFilterOperation* colorMatrixOperation = static_cast<BasicColorMatrixFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

857

filterValue = CSSFilterValue::create(CSSFilterValue::GrayscaleFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

858

filterValue->append(cssValuePool().createValue(colorMatrixOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

859

break;

860

}

861

case FilterOperation::SEPIA: {

862

BasicColorMatrixFilterOperation* colorMatrixOperation = static_cast<BasicColorMatrixFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

863

filterValue = CSSFilterValue::create(CSSFilterValue::SepiaFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

864

filterValue->append(cssValuePool().createValue(colorMatrixOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

865

break;

866

}

867

case FilterOperation::SATURATE: {

868

BasicColorMatrixFilterOperation* colorMatrixOperation = static_cast<BasicColorMatrixFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

869

filterValue = CSSFilterValue::create(CSSFilterValue::SaturateFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

870

filterValue->append(cssValuePool().createValue(colorMatrixOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

871

break;

872

}

873

case FilterOperation::HUE_ROTATE: {

874

BasicColorMatrixFilterOperation* colorMatrixOperation = static_cast<BasicColorMatrixFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

875

filterValue = CSSFilterValue::create(CSSFilterValue::HueRotateFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

876

filterValue->append(cssValuePool().createValue(colorMatrixOperation->amount(), CSSPrimitiveValue::CSS_DEG));

877

break;

878

}

879

case FilterOperation::INVERT: {

880

BasicComponentTransferFilterOperation* componentTransferOperation = static_cast<BasicComponentTransferFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

881

filterValue = CSSFilterValue::create(CSSFilterValue::InvertFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

882

filterValue->append(cssValuePool().createValue(componentTransferOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

883

break;

884

}

885

case FilterOperation::OPACITY: {

886

BasicComponentTransferFilterOperation* componentTransferOperation = static_cast<BasicComponentTransferFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

887

filterValue = CSSFilterValue::create(CSSFilterValue::OpacityFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

888

filterValue->append(cssValuePool().createValue(componentTransferOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

889

break;

890

}

891

case FilterOperation::BRIGHTNESS: {

892

BasicComponentTransferFilterOperation* brightnessOperation = static_cast<BasicComponentTransferFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

893

filterValue = CSSFilterValue::create(CSSFilterValue::BrightnessFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

894

filterValue->append(cssValuePool().createValue(brightnessOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

895

break;

896

}

897

case FilterOperation::CONTRAST: {

898

BasicComponentTransferFilterOperation* contrastOperation = static_cast<BasicComponentTransferFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

899

filterValue = CSSFilterValue::create(CSSFilterValue::ContrastFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

900

filterValue->append(cssValuePool().createValue(contrastOperation->amount(), CSSPrimitiveValue::CSS_NUMBER));

901

break;

902

}

903

case FilterOperation::BLUR: {

904

BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

905

filterValue = CSSFilterValue::create(CSSFilterValue::BlurFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

906

filterValue->append(zoomAdjustedPixelValue(blurOperation->stdDeviation().value(), style));

907

break;

908

}

909

case FilterOperation::DROP_SHADOW: {

910

DropShadowFilterOperation* dropShadowOperation = static_cast<DropShadowFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

911

filterValue = CSSFilterValue::create(CSSFilterValue::DropShadowFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

912

// We want our computed style to look like that of a text shadow (has neither spread nor inset style).

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

913

OwnPtr<ShadowData> shadow = ShadowData::create(dropShadowOperation->location(), dropShadowOperation->stdDeviation(), 0, Normal, dropShadowOperation->color());

914

filterValue->append(valueForShadow(shadow.get(), CSSPropertyTextShadow, style));

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

915

break;

916

}

917

case FilterOperation::VALIDATED_CUSTOM:

918

// ValidatedCustomFilterOperation is not supposed to end up in the RenderStyle.

919

ASSERT_NOT_REACHED();

920

break;

921

case FilterOperation::CUSTOM: {

922

CustomFilterOperation* customOperation = static_cast<CustomFilterOperation*>(filterOperation);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

923

filterValue = CSSFilterValue::create(CSSFilterValue::CustomFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

924

925

// The output should be verbose, even if the values are the default ones.

926

927

ASSERT(customOperation->program());

928

StyleCustomFilterProgram* program = static_cast<StyleCustomFilterProgram*>(customOperation->program());

929

930

RefPtr<CSSValueList> shadersList = CSSValueList::createSpaceSeparated();

931

if (program->vertexShader())

932

shadersList->append(program->vertexShader()->cssValue());

933

else

934

shadersList->append(cssValuePool().createIdentifierValue(CSSValueNone));

935

936

const CustomFilterProgramMixSettings mixSettings = program->mixSettings();

937

if (program->fragmentShader()) {

938

if (program->programType() == PROGRAM_TYPE_BLENDS_ELEMENT_TEXTURE) {

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

939

RefPtr<CSSMixFunctionValue> mixFunction = CSSMixFunctionValue::create();

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

940

mixFunction->append(program->fragmentShader()->cssValue());

941

mixFunction->append(cssValuePool().createValue(mixSettings.blendMode));

942

mixFunction->append(cssValuePool().createValue(mixSettings.compositeOperator));

943

shadersList->append(mixFunction.release());

944

} else

945

shadersList->append(program->fragmentShader()->cssValue());

946

}

947

else

948

shadersList->append(cssValuePool().createIdentifierValue(CSSValueNone));

949

950

filterValue->append(shadersList.release());

951

952

RefPtr<CSSValueList> meshParameters = CSSValueList::createSpaceSeparated();

953

meshParameters->append(cssValuePool().createValue(customOperation->meshColumns(), CSSPrimitiveValue::CSS_NUMBER));

954

meshParameters->append(cssValuePool().createValue(customOperation->meshRows(), CSSPrimitiveValue::CSS_NUMBER));

955

956

// FIXME: The specification doesn't have any "attached" identifier. Should we add one?

957

// https://bugs.webkit.org/show_bug.cgi?id=72700

958

if (customOperation->meshType() == MeshTypeDetached)

959

meshParameters->append(cssValuePool().createIdentifierValue(CSSValueDetached));

960

961

filterValue->append(meshParameters.release());

962

963

const CustomFilterParameterList& parameters = customOperation->parameters();

964

size_t parametersSize = parameters.size();

965

if (!parametersSize)

966

break;

967

RefPtr<CSSValueList> parametersCSSValue = CSSValueList::createCommaSeparated();

968

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

969

const CustomFilterParameter* parameter = parameters.at(i).get();

970

RefPtr<CSSValueList> parameterCSSNameAndValue = CSSValueList::createSpaceSeparated();

971

parameterCSSNameAndValue->append(cssValuePool().createValue(parameter->name(), CSSPrimitiveValue::CSS_STRING));

972

parameterCSSNameAndValue->append(valueForCustomFilterParameter(renderer, style, parameter));

973

parametersCSSValue->append(parameterCSSNameAndValue.release());

974

}

975

976

filterValue->append(parametersCSSValue.release());

977

break;

978

}

979

default:

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

980

filterValue = CSSFilterValue::create(CSSFilterValue::UnknownFilterOperation);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

981

break;

982

}

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

983

list->append(filterValue.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

984

}

985

986

return list.release();

987

}

988

989

static PassRefPtr<CSSValue> valueForGridTrackBreadth(const GridLength& trackBreadth, const RenderStyle* style, RenderView* renderView)

990

{

991

if (!trackBreadth.isLength()) {

992

String flex = String::number(trackBreadth.flex());

993

flex.append("fr");

994

return cssValuePool().createValue(flex, CSSPrimitiveValue::CSS_DIMENSION);

995

}

996

997

const Length& trackBreadthLength = trackBreadth.length();

998

if (trackBreadthLength.isAuto())

999

return cssValuePool().createIdentifierValue(CSSValueAuto);

1000

if (trackBreadthLength.isViewportPercentage())

1001

return zoomAdjustedPixelValue(valueForLength(trackBreadthLength, 0, renderView), style);

1002

return zoomAdjustedPixelValueForLength(trackBreadthLength, style);

1003

}

1004

1005

static PassRefPtr<CSSValue> valueForGridTrackSize(const GridTrackSize& trackSize, const RenderStyle* style, RenderView* renderView)

1006

{

1007

switch (trackSize.type()) {

1008

case LengthTrackSizing:

1009

return valueForGridTrackBreadth(trackSize.length(), style, renderView);

1010

case MinMaxTrackSizing:

1011

RefPtr<CSSValueList> minMaxTrackBreadths = CSSValueList::createCommaSeparated();

1012

minMaxTrackBreadths->append(valueForGridTrackBreadth(trackSize.minTrackBreadth(), style, renderView));

1013

minMaxTrackBreadths->append(valueForGridTrackBreadth(trackSize.maxTrackBreadth(), style, renderView));

1014

return CSSFunctionValue::create("minmax(", minMaxTrackBreadths);

1015

}

1016

ASSERT_NOT_REACHED();

1017

return 0;

1018

}

1019

Torne (Richard Coles)

2013-05-13 16:52:28 +0100

[diff] [blame]

1020

static void addValuesForNamedGridLinesAtIndex(const NamedGridLinesMap& namedGridLines, size_t i, CSSValueList& list)

1021

{

1022

// Note that this won't return the results in the order specified in the style sheet,

1023

// which is probably fine as we stil *do* return all the expected values.

1024

NamedGridLinesMap::const_iterator it = namedGridLines.begin();

1025

NamedGridLinesMap::const_iterator end = namedGridLines.end();

1026

for (; it != end; ++it) {

1027

const Vector<size_t>& linesIndexes = it->value;

1028

for (size_t j = 0; j < linesIndexes.size(); ++j) {

1029

if (linesIndexes[j] != i)

1030

continue;

1031

1032

list.append(cssValuePool().createValue(it->key, CSSPrimitiveValue::CSS_STRING));

break;

}

}

}

static PassRefPtr<CSSValue> valueForGridTrackList(const Vector<GridTrackSize>& trackSizes, const NamedGridLinesMap& namedGridLines, const RenderStyle* style, RenderView* renderView)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1039

{

1040

// Handle the 'none' case here.

Torne (Richard Coles)

2013-05-13 16:52:28 +0100

[diff] [blame]

1041

if (!trackSizes.size()) {

1042

ASSERT(namedGridLines.isEmpty());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1043

return cssValuePool().createIdentifierValue(CSSValueNone);

Torne (Richard Coles)

2013-05-13 16:52:28 +0100

[diff] [blame]

1044

}

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1045

1046

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

Torne (Richard Coles)

2013-05-13 16:52:28 +0100

[diff] [blame]

1047

for (size_t i = 0; i < trackSizes.size(); ++i) {

1048

addValuesForNamedGridLinesAtIndex(namedGridLines, i, *list);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1049

list->append(valueForGridTrackSize(trackSizes[i], style, renderView));

Torne (Richard Coles)

2013-05-13 16:52:28 +0100

[diff] [blame]

1050

}

1051

// Those are the trailing <string>* allowed in the syntax.

1052

addValuesForNamedGridLinesAtIndex(namedGridLines, trackSizes.size(), *list);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1053

return list.release();

1054

}

1055

1056

static PassRefPtr<CSSValue> valueForGridPosition(const GridPosition& position)

1057

{

1058

if (position.isAuto())

1059

return cssValuePool().createIdentifierValue(CSSValueAuto);

1060

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1061

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

1062

if (position.isSpan()) {

1063

list->append(cssValuePool().createIdentifierValue(CSSValueSpan));

1064

list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::CSS_NUMBER));

1065

} else

1066

list->append(cssValuePool().createValue(position.integerPosition(), CSSPrimitiveValue::CSS_NUMBER));

1067

1068

if (!position.namedGridLine().isNull())

1069

list->append(cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::CSS_STRING));

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1070

return list;

1071

}

1072

static PassRefPtr<CSSValue> createTransitionPropertyValue(const CSSAnimationData* animation)

1073

{

1074

RefPtr<CSSValue> propertyValue;

1075

if (animation->animationMode() == CSSAnimationData::AnimateNone)

1076

propertyValue = cssValuePool().createIdentifierValue(CSSValueNone);

1077

else if (animation->animationMode() == CSSAnimationData::AnimateAll)

1078

propertyValue = cssValuePool().createIdentifierValue(CSSValueAll);

1079

else

1080

propertyValue = cssValuePool().createValue(getPropertyNameString(animation->property()), CSSPrimitiveValue::CSS_STRING);

1081

return propertyValue.release();

1082

}

1083

static PassRefPtr<CSSValue> getTransitionPropertyValue(const CSSAnimationDataList* animList)

1084

{

1085

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1086

if (animList) {

1087

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

1088

list->append(createTransitionPropertyValue(animList->animation(i)));

1089

} else

1090

list->append(cssValuePool().createIdentifierValue(CSSValueAll));

1091

return list.release();

1092

}

1093

1094

static PassRefPtr<CSSValue> getDelayValue(const CSSAnimationDataList* animList)

1095

{

1096

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1097

if (animList) {

1098

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

1099

list->append(cssValuePool().createValue(animList->animation(i)->delay(), CSSPrimitiveValue::CSS_S));

1100

} else {

1101

// Note that initialAnimationDelay() is used for both transitions and animations

1102

list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));

1103

}

1104

return list.release();

1105

}

1106

1107

static PassRefPtr<CSSValue> getDurationValue(const CSSAnimationDataList* animList)

1108

{

1109

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1110

if (animList) {

1111

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

1112

list->append(cssValuePool().createValue(animList->animation(i)->duration(), CSSPrimitiveValue::CSS_S));

1113

} else {

1114

// Note that initialAnimationDuration() is used for both transitions and animations

1115

list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));

1116

}

1117

return list.release();

1118

}

1119

1120

static PassRefPtr<CSSValue> createTimingFunctionValue(const TimingFunction* timingFunction)

1121

{

1122

if (timingFunction->isCubicBezierTimingFunction()) {

1123

const CubicBezierTimingFunction* bezierTimingFunction = static_cast<const CubicBezierTimingFunction*>(timingFunction);

1124

if (bezierTimingFunction->timingFunctionPreset() != CubicBezierTimingFunction::Custom) {

1125

CSSValueID valueId = CSSValueInvalid;

1126

switch (bezierTimingFunction->timingFunctionPreset()) {

1127

case CubicBezierTimingFunction::Ease:

1128

valueId = CSSValueEase;

1129

break;

1130

case CubicBezierTimingFunction::EaseIn:

1131

valueId = CSSValueEaseIn;

1132

break;

1133

case CubicBezierTimingFunction::EaseOut:

1134

valueId = CSSValueEaseOut;

1135

break;

1136

case CubicBezierTimingFunction::EaseInOut:

1137

valueId = CSSValueEaseInOut;

1138

break;

1139

default:

1140

ASSERT_NOT_REACHED();

1141

return 0;

1142

}

1143

return cssValuePool().createIdentifierValue(valueId);

1144

}

1145

return CSSCubicBezierTimingFunctionValue::create(bezierTimingFunction->x1(), bezierTimingFunction->y1(), bezierTimingFunction->x2(), bezierTimingFunction->y2());

1146

}

1147

1148

if (timingFunction->isStepsTimingFunction()) {

1149

const StepsTimingFunction* stepsTimingFunction = static_cast<const StepsTimingFunction*>(timingFunction);

1150

return CSSStepsTimingFunctionValue::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart());

1151

}

1152

1153

return CSSLinearTimingFunctionValue::create();

1154

}

1155

1156

static PassRefPtr<CSSValue> getTimingFunctionValue(const CSSAnimationDataList* animList)

1157

{

1158

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1159

if (animList) {

1160

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

1161

list->append(createTimingFunctionValue(animList->animation(i)->timingFunction().get()));

1162

} else

1163

// Note that initialAnimationTimingFunction() is used for both transitions and animations

1164

list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));

1165

return list.release();

1166

}

1167

1168

static PassRefPtr<CSSValue> createLineBoxContainValue(unsigned lineBoxContain)

1169

{

1170

if (!lineBoxContain)

1171

return cssValuePool().createIdentifierValue(CSSValueNone);

1172

return CSSLineBoxContainValue::create(lineBoxContain);

1173

}

1174

1175

CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)

1176

: m_node(n)

1177

, m_allowVisitedStyle(allowVisitedStyle)

1178

, m_refCount(1)

1179

{

1180

unsigned nameWithoutColonsStart = pseudoElementName[0] == ':' ? (pseudoElementName[1] == ':' ? 2 : 1) : 0;

1181

m_pseudoElementSpecifier = CSSSelector::pseudoId(CSSSelector::parsePseudoType(

1182

AtomicString(pseudoElementName.substring(nameWithoutColonsStart))));

1183

}

1184

1185

CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration()

{

}

void CSSComputedStyleDeclaration::ref()

{

++m_refCount;

}

void CSSComputedStyleDeclaration::deref()

{

ASSERT(m_refCount);

if (!--m_refCount)

delete this;

}

String CSSComputedStyleDeclaration::cssText() const

1202

{

1203

StringBuilder result;

1204

const Vector<CSSPropertyID>& properties = computableProperties();

1205

1206

for (unsigned i = 0; i < properties.size(); i++) {

1207

if (i)

1208

result.append(' ');

1209

result.append(getPropertyName(properties[i]));

1210

result.append(": ", 2);

1211

result.append(getPropertyValue(properties[i]));

result.append(';');

}

return result.toString();

1216

}

1217

1218

void CSSComputedStyleDeclaration::setCssText(const String&, ExceptionCode& ec)

1219

{

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

1220

ec = NoModificationAllowedError;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1221

}

1222

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1223

static CSSValueID cssIdentifierForFontSizeKeyword(int keywordSize)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1224

{

1225

ASSERT_ARG(keywordSize, keywordSize);

1226

ASSERT_ARG(keywordSize, keywordSize <= 8);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1227

return static_cast<CSSValueID>(CSSValueXxSmall + keywordSize - 1);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1228

}

1229

1230

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword() const

{

if (!m_node)

return 0;

m_node->document()->updateLayoutIgnorePendingStylesheets();

1236

1237

RefPtr<RenderStyle> style = m_node->computedStyle(m_pseudoElementSpecifier);

if (!style)

return 0;

if (int keywordSize = style->fontDescription().keywordSize())

1242

return cssValuePool().createIdentifierValue(cssIdentifierForFontSizeKeyword(keywordSize));

1243

1244

1245

return zoomAdjustedPixelValue(style->fontDescription().computedPixelSize(), style.get());

1246

}

1247

1248

bool CSSComputedStyleDeclaration::useFixedFontDefaultSize() const

{

if (!m_node)

return false;

RefPtr<RenderStyle> style = m_node->computedStyle(m_pseudoElementSpecifier);

if (!style)

return false;

return style->fontDescription().useFixedDefaultSize();

1258

}

1259

1260

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::valueForShadow(const ShadowData* shadow, CSSPropertyID propertyID, const RenderStyle* style) const

1261

{

1262

if (!shadow)

1263

return cssValuePool().createIdentifierValue(CSSValueNone);

1264

1265

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1266

for (const ShadowData* s = shadow; s; s = s->next()) {

1267

RefPtr<CSSPrimitiveValue> x = zoomAdjustedPixelValue(s->x(), style);

1268

RefPtr<CSSPrimitiveValue> y = zoomAdjustedPixelValue(s->y(), style);

1269

RefPtr<CSSPrimitiveValue> blur = zoomAdjustedPixelValue(s->blur(), style);

1270

RefPtr<CSSPrimitiveValue> spread = propertyID == CSSPropertyTextShadow ? PassRefPtr<CSSPrimitiveValue>() : zoomAdjustedPixelValue(s->spread(), style);

1271

RefPtr<CSSPrimitiveValue> style = propertyID == CSSPropertyTextShadow || s->style() == Normal ? PassRefPtr<CSSPrimitiveValue>() : cssValuePool().createIdentifierValue(CSSValueInset);

1272

RefPtr<CSSPrimitiveValue> color = cssValuePool().createColorValue(s->color().rgb());

1273

list->prepend(ShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), style.release(), color.release()));

1274

}

1275

return list.release();

1276

}

1277

1278

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID) const

1279

{

1280

return getPropertyCSSValue(propertyID, UpdateLayout);

1281

}

1282

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1283

static CSSValueID identifierForFamily(const AtomicString& family)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1284

{

1285

if (family == cursiveFamily)

1286

return CSSValueCursive;

1287

if (family == fantasyFamily)

1288

return CSSValueFantasy;

1289

if (family == monospaceFamily)

1290

return CSSValueMonospace;

1291

if (family == pictographFamily)

1292

return CSSValueWebkitPictograph;

1293

if (family == sansSerifFamily)

1294

return CSSValueSansSerif;

1295

if (family == serifFamily)

1296

return CSSValueSerif;

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1297

return CSSValueInvalid;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1298

}

1299

1300

static PassRefPtr<CSSPrimitiveValue> valueForFamily(const AtomicString& family)

1301

{

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1302

if (CSSValueID familyIdentifier = identifierForFamily(family))

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1303

return cssValuePool().createIdentifierValue(familyIdentifier);

1304

return cssValuePool().createValue(family.string(), CSSPrimitiveValue::CSS_STRING);

1305

}

1306

1307

static PassRefPtr<CSSValue> renderTextDecorationFlagsToCSSValue(int textDecoration)

1308

{

1309

// Blink value is ignored.

1310

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

1311

if (textDecoration & TextDecorationUnderline)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1312

list->append(cssValuePool().createIdentifierValue(CSSValueUnderline));

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

1313

if (textDecoration & TextDecorationOverline)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1314

list->append(cssValuePool().createIdentifierValue(CSSValueOverline));

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

1315

if (textDecoration & TextDecorationLineThrough)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1316

list->append(cssValuePool().createIdentifierValue(CSSValueLineThrough));

1317

1318

if (!list->length())

1319

return cssValuePool().createIdentifierValue(CSSValueNone);

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1320

return list.release();

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1321

}

1322

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1323

static PassRefPtr<CSSValue> renderTextDecorationStyleFlagsToCSSValue(TextDecorationStyle textDecorationStyle)

1324

{

1325

switch (textDecorationStyle) {

1326

case TextDecorationStyleSolid:

1327

return cssValuePool().createIdentifierValue(CSSValueSolid);

1328

case TextDecorationStyleDouble:

1329

return cssValuePool().createIdentifierValue(CSSValueDouble);

1330

case TextDecorationStyleDotted:

1331

return cssValuePool().createIdentifierValue(CSSValueDotted);

1332

case TextDecorationStyleDashed:

1333

return cssValuePool().createIdentifierValue(CSSValueDashed);

1334

case TextDecorationStyleWavy:

1335

return cssValuePool().createIdentifierValue(CSSValueWavy);

1336

}

1337

1338

ASSERT_NOT_REACHED();

1339

return cssValuePool().createExplicitInitialValue();

1340

}

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1341

1342

static PassRefPtr<CSSValue> fillRepeatToCSSValue(EFillRepeat xRepeat, EFillRepeat yRepeat)

1343

{

1344

// For backwards compatibility, if both values are equal, just return one of them. And

1345

// if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.

1346

if (xRepeat == yRepeat)

1347

return cssValuePool().createValue(xRepeat);

1348

if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)

1349

return cssValuePool().createIdentifierValue(CSSValueRepeatX);

1350

if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)

1351

return cssValuePool().createIdentifierValue(CSSValueRepeatY);

1352

1353

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

1354

list->append(cssValuePool().createValue(xRepeat));

1355

list->append(cssValuePool().createValue(yRepeat));

1356

return list.release();

1357

}

1358

1359

static PassRefPtr<CSSValue> fillSizeToCSSValue(const FillSize& fillSize, const RenderStyle* style)

1360

{

1361

if (fillSize.type == Contain)

1362

return cssValuePool().createIdentifierValue(CSSValueContain);

1363

1364

if (fillSize.type == Cover)

1365

return cssValuePool().createIdentifierValue(CSSValueCover);

1366

1367

if (fillSize.size.height().isAuto())

1368

return zoomAdjustedPixelValueForLength(fillSize.size.width(), style);

1369

1370

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

1371

list->append(zoomAdjustedPixelValueForLength(fillSize.size.width(), style));

1372

list->append(zoomAdjustedPixelValueForLength(fillSize.size.height(), style));

1373

return list.release();

1374

}

1375

1376

static PassRefPtr<CSSValue> contentToCSSValue(const RenderStyle* style)

1377

{

1378

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

1379

for (const ContentData* contentData = style->contentData(); contentData; contentData = contentData->next()) {

1380

if (contentData->isCounter()) {

1381

const CounterContent* counter = static_cast<const CounterContentData*>(contentData)->counter();

1382

ASSERT(counter);

1383

list->append(cssValuePool().createValue(counter->identifier(), CSSPrimitiveValue::CSS_COUNTER_NAME));

1384

} else if (contentData->isImage()) {

1385

const StyleImage* image = static_cast<const ImageContentData*>(contentData)->image();

1386

ASSERT(image);

1387

list->append(image->cssValue());

1388

} else if (contentData->isText())

1389

list->append(cssValuePool().createValue(static_cast<const TextContentData*>(contentData)->text(), CSSPrimitiveValue::CSS_STRING));

1390

}

1391

if (!style->regionThread().isNull())

1392

list->append(cssValuePool().createValue(style->regionThread(), CSSPrimitiveValue::CSS_STRING));

1393

return list.release();

1394

}

1395

1396

static PassRefPtr<CSSValue> counterToCSSValue(const RenderStyle* style, CSSPropertyID propertyID)

1397

{

1398

const CounterDirectiveMap* map = style->counterDirectives();

if (!map)

return 0;

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

1403

for (CounterDirectiveMap::const_iterator it = map->begin(); it != map->end(); ++it) {

1404

list->append(cssValuePool().createValue(it->key, CSSPrimitiveValue::CSS_STRING));

1405

short number = propertyID == CSSPropertyCounterIncrement ? it->value.incrementValue() : it->value.resetValue();

1406

list->append(cssValuePool().createValue((double)number, CSSPrimitiveValue::CSS_NUMBER));

1407

}

1408

return list.release();

1409

}

1410

1411

static void logUnimplementedPropertyID(CSSPropertyID propertyID)

1412

{

1413

DEFINE_STATIC_LOCAL(HashSet<CSSPropertyID>, propertyIDSet, ());

1414

if (!propertyIDSet.add(propertyID).isNewEntry)

1415

return;

1416

1417

LOG_ERROR("WebKit does not yet implement getComputedStyle for '%s'.", getPropertyName(propertyID));

1418

}

1419

1420

static PassRefPtr<CSSValueList> fontFamilyFromStyle(RenderStyle* style)

1421

{

1422

const FontFamily& firstFamily = style->fontDescription().family();

1423

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1424

for (const FontFamily* family = &firstFamily; family; family = family->next())

1425

list->append(valueForFamily(family->family()));

1426

return list.release();

1427

}

1428

1429

static PassRefPtr<CSSPrimitiveValue> lineHeightFromStyle(RenderStyle* style, RenderView* renderView)

1430

{

1431

Length length = style->lineHeight();

1432

if (length.isNegative())

1433

return cssValuePool().createIdentifierValue(CSSValueNormal);

1434

if (length.isPercent())

1435

// This is imperfect, because it doesn't include the zoom factor and the real computation

1436

// for how high to be in pixels does include things like minimum font size and the zoom factor.

1437

// On the other hand, since font-size doesn't include the zoom factor, we really can't do

1438

// that here either.

1439

return zoomAdjustedPixelValue(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, style);

1440

return zoomAdjustedPixelValue(valueForLength(length, 0, renderView), style);

1441

}

1442

1443

static PassRefPtr<CSSPrimitiveValue> fontSizeFromStyle(RenderStyle* style)

1444

{

1445

return zoomAdjustedPixelValue(style->fontDescription().computedPixelSize(), style);

1446

}

1447

1448

static PassRefPtr<CSSPrimitiveValue> fontStyleFromStyle(RenderStyle* style)

1449

{

1450

if (style->fontDescription().italic())

1451

return cssValuePool().createIdentifierValue(CSSValueItalic);

1452

return cssValuePool().createIdentifierValue(CSSValueNormal);

1453

}

1454

1455

static PassRefPtr<CSSPrimitiveValue> fontVariantFromStyle(RenderStyle* style)

1456

{

1457

if (style->fontDescription().smallCaps())

1458

return cssValuePool().createIdentifierValue(CSSValueSmallCaps);

1459

return cssValuePool().createIdentifierValue(CSSValueNormal);

1460

}

1461

1462

static PassRefPtr<CSSPrimitiveValue> fontWeightFromStyle(RenderStyle* style)

1463

{

1464

switch (style->fontDescription().weight()) {

1465

case FontWeight100:

1466

return cssValuePool().createIdentifierValue(CSSValue100);

1467

case FontWeight200:

1468

return cssValuePool().createIdentifierValue(CSSValue200);

1469

case FontWeight300:

1470

return cssValuePool().createIdentifierValue(CSSValue300);

1471

case FontWeightNormal:

1472

return cssValuePool().createIdentifierValue(CSSValueNormal);

1473

case FontWeight500:

1474

return cssValuePool().createIdentifierValue(CSSValue500);

1475

case FontWeight600:

1476

return cssValuePool().createIdentifierValue(CSSValue600);

1477

case FontWeightBold:

1478

return cssValuePool().createIdentifierValue(CSSValueBold);

1479

case FontWeight800:

1480

return cssValuePool().createIdentifierValue(CSSValue800);

1481

case FontWeight900:

1482

return cssValuePool().createIdentifierValue(CSSValue900);

1483

}

1484

ASSERT_NOT_REACHED();

1485

return cssValuePool().createIdentifierValue(CSSValueNormal);

1486

}

1487

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1488

static bool isLayoutDependent(CSSPropertyID propertyID, PassRefPtr<RenderStyle> style, RenderObject* renderer)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1489

{

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1490

// Some properties only depend on layout in certain conditions which

1491

// are specified in the main switch statement below. So we can avoid

1492

// forcing layout in those conditions. The conditions in this switch

1493

// statement must remain in sync with the conditions in the main switch.

1494

// FIXME: Some of these cases could be narrowed down or optimized better.

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1495

switch (propertyID) {

1496

case CSSPropertyBottom:

1497

case CSSPropertyHeight:

1498

case CSSPropertyLeft:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1499

case CSSPropertyRight:

1500

case CSSPropertyTop:

1501

case CSSPropertyWebkitPerspectiveOrigin:

1502

case CSSPropertyWebkitTransform:

1503

case CSSPropertyWebkitTransformOrigin:

1504

case CSSPropertyWidth:

1505

case CSSPropertyWebkitFilter:

1506

return true;

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1507

case CSSPropertyMargin:

1508

return renderer && renderer->isBox() && (!style || !style->marginBottom().isFixed() || !style->marginTop().isFixed() || !style->marginLeft().isFixed() || !style->marginRight().isFixed());

1509

case CSSPropertyMarginLeft:

1510

return renderer && renderer->isBox() && (!style || !style->marginLeft().isFixed());

1511

case CSSPropertyMarginRight:

1512

return renderer && renderer->isBox() && (!style || !style->marginRight().isFixed());

1513

case CSSPropertyMarginTop:

1514

return renderer && renderer->isBox() && (!style || !style->marginTop().isFixed());

1515

case CSSPropertyMarginBottom:

1516

return renderer && renderer->isBox() && (!style || !style->marginBottom().isFixed());

1517

case CSSPropertyPadding:

1518

return renderer && renderer->isBox() && (!style || !style->paddingBottom().isFixed() || !style->paddingTop().isFixed() || !style->paddingLeft().isFixed() || !style->paddingRight().isFixed());

1519

case CSSPropertyPaddingBottom:

1520

return renderer && renderer->isBox() && (!style || !style->paddingBottom().isFixed());

1521

case CSSPropertyPaddingLeft:

1522

return renderer && renderer->isBox() && (!style || !style->paddingLeft().isFixed());

1523

case CSSPropertyPaddingRight:

1524

return renderer && renderer->isBox() && (!style || !style->paddingRight().isFixed());

1525

case CSSPropertyPaddingTop:

1526

return renderer && renderer->isBox() && (!style || !style->paddingTop().isFixed());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

default:

return false;

}

}

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1532

PassRefPtr<RenderStyle> CSSComputedStyleDeclaration::computeRenderStyle(CSSPropertyID propertyID) const

1533

{

1534

Node* styledNode = this->styledNode();

1535

ASSERT(styledNode);

1536

RenderObject* renderer = styledNode->renderer();

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

1537

if (renderer && renderer->isComposited() && AnimationController::supportsAcceleratedAnimationOfProperty(propertyID) && !RuntimeEnabledFeatures::webAnimationsCSSEnabled()) {

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1538

AnimationUpdateBlock animationUpdateBlock(renderer->animation());

1539

if (m_pseudoElementSpecifier && !styledNode->isPseudoElement()) {

1540

// FIXME: This cached pseudo style will only exist if the animation has been run at least once.

1541

return renderer->animation()->getAnimatedStyleForRenderer(renderer)->getCachedPseudoStyle(m_pseudoElementSpecifier);

1542

}

1543

return renderer->animation()->getAnimatedStyleForRenderer(renderer);

1544

}

1545

return styledNode->computedStyle(styledNode->isPseudoElement() ? NOPSEUDO : m_pseudoElementSpecifier);

1546

}

1547

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1548

Node* CSSComputedStyleDeclaration::styledNode() const

{

if (!m_node)

return 0;

if (m_node->isElementNode()) {

1553

if (PseudoElement* element = toElement(m_node.get())->pseudoElement(m_pseudoElementSpecifier))

return element;

}

return m_node.get();

}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const

1560

{

1561

Node* styledNode = this->styledNode();

1562

if (!styledNode)

1563

return 0;

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1564

RenderObject* renderer = styledNode->renderer();

1565

RefPtr<RenderStyle> style;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1566

1567

if (updateLayout) {

1568

Document* document = styledNode->document();

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1569

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1570

document->updateStyleForNodeIfNeeded(styledNode);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1571

1572

// The style recalc could have caused the styled node to be discarded or replaced

1573

// if it was a PseudoElement so we need to update it.

1574

styledNode = this->styledNode();

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1575

renderer = styledNode->renderer();

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1576

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1577

style = computeRenderStyle(propertyID);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1578

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1579

bool forceFullLayout = isLayoutDependent(propertyID, style, renderer)

1580

|| styledNode->isInShadowTree()

1581

|| (document->styleResolverIfExists() && document->styleResolverIfExists()->hasViewportDependentMediaQueries() && document->ownerElement())

1582

|| document->seamlessParentIFrame();

1583

1584

if (forceFullLayout) {

1585

document->updateLayoutIgnorePendingStylesheets();

1586

styledNode = this->styledNode();

1587

style = computeRenderStyle(propertyID);

1588

renderer = styledNode->renderer();

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1589

}

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1590

} else {

1591

style = computeRenderStyle(propertyID);

1592

}

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

if (!style)

return 0;

propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction(), style->writingMode());

1598

1599

switch (propertyID) {

1600

case CSSPropertyInvalid:

1601

case CSSPropertyVariable:

1602

break;

1603

1604

case CSSPropertyBackgroundColor:

1605

return cssValuePool().createColorValue(m_allowVisitedStyle? style->visitedDependentColor(CSSPropertyBackgroundColor).rgb() : style->backgroundColor().rgb());

1606

case CSSPropertyBackgroundImage:

1607

case CSSPropertyWebkitMaskImage: {

1608

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskImage ? style->maskLayers() : style->backgroundLayers();

1609

if (!layers)

1610

return cssValuePool().createIdentifierValue(CSSValueNone);

1611

1612

if (!layers->next()) {

1613

if (layers->image())

1614

return layers->image()->cssValue();

1615

1616

return cssValuePool().createIdentifierValue(CSSValueNone);

1617

}

1618

1619

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1620

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {

1621

if (currLayer->image())

1622

list->append(currLayer->image()->cssValue());

1623

else

1624

list->append(cssValuePool().createIdentifierValue(CSSValueNone));

1625

}

1626

return list.release();

1627

}

1628

case CSSPropertyBackgroundSize:

1629

case CSSPropertyWebkitBackgroundSize:

1630

case CSSPropertyWebkitMaskSize: {

1631

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskSize ? style->maskLayers() : style->backgroundLayers();

1632

if (!layers->next())

1633

return fillSizeToCSSValue(layers->size(), style.get());

1634

1635

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1636

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1637

list->append(fillSizeToCSSValue(currLayer->size(), style.get()));

1638

1639

return list.release();

1640

}

1641

case CSSPropertyBackgroundRepeat:

1642

case CSSPropertyWebkitMaskRepeat: {

1643

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskRepeat ? style->maskLayers() : style->backgroundLayers();

1644

if (!layers->next())

1645

return fillRepeatToCSSValue(layers->repeatX(), layers->repeatY());

1646

1647

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1648

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1649

list->append(fillRepeatToCSSValue(currLayer->repeatX(), currLayer->repeatY()));

1650

1651

return list.release();

1652

}

1653

case CSSPropertyWebkitBackgroundComposite:

1654

case CSSPropertyWebkitMaskComposite: {

1655

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskComposite ? style->maskLayers() : style->backgroundLayers();

1656

if (!layers->next())

1657

return cssValuePool().createValue(layers->composite());

1658

1659

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1660

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1661

list->append(cssValuePool().createValue(currLayer->composite()));

1662

1663

return list.release();

1664

}

1665

case CSSPropertyBackgroundAttachment: {

1666

const FillLayer* layers = style->backgroundLayers();

1667

if (!layers->next())

1668

return cssValuePool().createValue(layers->attachment());

1669

1670

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1671

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1672

list->append(cssValuePool().createValue(currLayer->attachment()));

1673

1674

return list.release();

1675

}

1676

case CSSPropertyBackgroundClip:

1677

case CSSPropertyBackgroundOrigin:

1678

case CSSPropertyWebkitBackgroundClip:

1679

case CSSPropertyWebkitBackgroundOrigin:

1680

case CSSPropertyWebkitMaskClip:

1681

case CSSPropertyWebkitMaskOrigin: {

1682

const FillLayer* layers = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? style->maskLayers() : style->backgroundLayers();

1683

bool isClip = propertyID == CSSPropertyBackgroundClip || propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyWebkitMaskClip;

1684

if (!layers->next()) {

1685

EFillBox box = isClip ? layers->clip() : layers->origin();

1686

return cssValuePool().createValue(box);

1687

}

1688

1689

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1690

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {

1691

EFillBox box = isClip ? currLayer->clip() : currLayer->origin();

1692

list->append(cssValuePool().createValue(box));

1693

}

1694

1695

return list.release();

1696

}

1697

case CSSPropertyBackgroundPosition:

1698

case CSSPropertyWebkitMaskPosition: {

1699

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPosition ? style->maskLayers() : style->backgroundLayers();

1700

if (!layers->next())

1701

return createPositionListForLayer(propertyID, layers, style.get());

1702

1703

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1704

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1705

list->append(createPositionListForLayer(propertyID, currLayer, style.get()));

1706

return list.release();

1707

}

1708

case CSSPropertyBackgroundPositionX:

1709

case CSSPropertyWebkitMaskPositionX: {

1710

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPositionX ? style->maskLayers() : style->backgroundLayers();

1711

if (!layers->next())

1712

return cssValuePool().createValue(layers->xPosition());

1713

1714

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1715

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1716

list->append(cssValuePool().createValue(currLayer->xPosition()));

1717

1718

return list.release();

1719

}

1720

case CSSPropertyBackgroundPositionY:

1721

case CSSPropertyWebkitMaskPositionY: {

1722

const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPositionY ? style->maskLayers() : style->backgroundLayers();

1723

if (!layers->next())

1724

return cssValuePool().createValue(layers->yPosition());

1725

1726

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1727

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

1728

list->append(cssValuePool().createValue(currLayer->yPosition()));

1729

1730

return list.release();

1731

}

1732

case CSSPropertyBorderCollapse:

1733

if (style->borderCollapse())

1734

return cssValuePool().createIdentifierValue(CSSValueCollapse);

1735

return cssValuePool().createIdentifierValue(CSSValueSeparate);

1736

case CSSPropertyBorderSpacing: {

1737

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

1738

list->append(zoomAdjustedPixelValue(style->horizontalBorderSpacing(), style.get()));

1739

list->append(zoomAdjustedPixelValue(style->verticalBorderSpacing(), style.get()));

1740

return list.release();

1741

}

1742

case CSSPropertyWebkitBorderHorizontalSpacing:

1743

return zoomAdjustedPixelValue(style->horizontalBorderSpacing(), style.get());

1744

case CSSPropertyWebkitBorderVerticalSpacing:

1745

return zoomAdjustedPixelValue(style->verticalBorderSpacing(), style.get());

1746

case CSSPropertyBorderImageSource:

1747

if (style->borderImageSource())

1748

return style->borderImageSource()->cssValue();

1749

return cssValuePool().createIdentifierValue(CSSValueNone);

1750

case CSSPropertyBorderTopColor:

1751

return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyBorderTopColor).rgb()) : currentColorOrValidColor(style.get(), style->borderTopColor());

1752

case CSSPropertyBorderRightColor:

1753

return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyBorderRightColor).rgb()) : currentColorOrValidColor(style.get(), style->borderRightColor());

1754

case CSSPropertyBorderBottomColor:

1755

return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyBorderBottomColor).rgb()) : currentColorOrValidColor(style.get(), style->borderBottomColor());

1756

case CSSPropertyBorderLeftColor:

1757

return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyBorderLeftColor).rgb()) : currentColorOrValidColor(style.get(), style->borderLeftColor());

1758

case CSSPropertyBorderTopStyle:

1759

return cssValuePool().createValue(style->borderTopStyle());

1760

case CSSPropertyBorderRightStyle:

1761

return cssValuePool().createValue(style->borderRightStyle());

1762

case CSSPropertyBorderBottomStyle:

1763

return cssValuePool().createValue(style->borderBottomStyle());

1764

case CSSPropertyBorderLeftStyle:

1765

return cssValuePool().createValue(style->borderLeftStyle());

1766

case CSSPropertyBorderTopWidth:

1767

return zoomAdjustedPixelValue(style->borderTopWidth(), style.get());

1768

case CSSPropertyBorderRightWidth:

1769

return zoomAdjustedPixelValue(style->borderRightWidth(), style.get());

1770

case CSSPropertyBorderBottomWidth:

1771

return zoomAdjustedPixelValue(style->borderBottomWidth(), style.get());

1772

case CSSPropertyBorderLeftWidth:

1773

return zoomAdjustedPixelValue(style->borderLeftWidth(), style.get());

1774

case CSSPropertyBottom:

1775

return getPositionOffsetValue(style.get(), CSSPropertyBottom, renderer, m_node->document()->renderView());

1776

case CSSPropertyWebkitBoxAlign:

1777

return cssValuePool().createValue(style->boxAlign());

1778

case CSSPropertyWebkitBoxDecorationBreak:

1779

if (style->boxDecorationBreak() == DSLICE)

1780

return cssValuePool().createIdentifierValue(CSSValueSlice);

1781

return cssValuePool().createIdentifierValue(CSSValueClone);

1782

case CSSPropertyWebkitBoxDirection:

1783

return cssValuePool().createValue(style->boxDirection());

1784

case CSSPropertyWebkitBoxFlex:

1785

return cssValuePool().createValue(style->boxFlex(), CSSPrimitiveValue::CSS_NUMBER);

1786

case CSSPropertyWebkitBoxFlexGroup:

1787

return cssValuePool().createValue(style->boxFlexGroup(), CSSPrimitiveValue::CSS_NUMBER);

1788

case CSSPropertyWebkitBoxLines:

1789

return cssValuePool().createValue(style->boxLines());

1790

case CSSPropertyWebkitBoxOrdinalGroup:

1791

return cssValuePool().createValue(style->boxOrdinalGroup(), CSSPrimitiveValue::CSS_NUMBER);

1792

case CSSPropertyWebkitBoxOrient:

1793

return cssValuePool().createValue(style->boxOrient());

1794

case CSSPropertyWebkitBoxPack:

1795

return cssValuePool().createValue(style->boxPack());

1796

case CSSPropertyWebkitBoxReflect:

1797

return valueForReflection(style->boxReflect(), style.get());

1798

case CSSPropertyBoxShadow:

1799

case CSSPropertyWebkitBoxShadow:

1800

return valueForShadow(style->boxShadow(), propertyID, style.get());

1801

case CSSPropertyCaptionSide:

1802

return cssValuePool().createValue(style->captionSide());

1803

case CSSPropertyClear:

1804

return cssValuePool().createValue(style->clear());

1805

case CSSPropertyColor:

1806

return cssValuePool().createColorValue(m_allowVisitedStyle ? style->visitedDependentColor(CSSPropertyColor).rgb() : style->color().rgb());

1807

case CSSPropertyWebkitPrintColorAdjust:

1808

return cssValuePool().createValue(style->printColorAdjust());

1809

case CSSPropertyWebkitColumnAxis:

1810

return cssValuePool().createValue(style->columnAxis());

1811

case CSSPropertyWebkitColumnCount:

1812

if (style->hasAutoColumnCount())

1813

return cssValuePool().createIdentifierValue(CSSValueAuto);

1814

return cssValuePool().createValue(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);

1815

case CSSPropertyWebkitColumnGap:

1816

if (style->hasNormalColumnGap())

1817

return cssValuePool().createIdentifierValue(CSSValueNormal);

1818

return zoomAdjustedPixelValue(style->columnGap(), style.get());

1819

case CSSPropertyWebkitColumnProgression:

1820

return cssValuePool().createValue(style->columnProgression());

1821

case CSSPropertyWebkitColumnRuleColor:

1822

return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->columnRuleColor());

1823

case CSSPropertyWebkitColumnRuleStyle:

1824

return cssValuePool().createValue(style->columnRuleStyle());

1825

case CSSPropertyWebkitColumnRuleWidth:

1826

return zoomAdjustedPixelValue(style->columnRuleWidth(), style.get());

1827

case CSSPropertyWebkitColumnSpan:

1828

return cssValuePool().createIdentifierValue(style->columnSpan() ? CSSValueAll : CSSValueNone);

1829

case CSSPropertyWebkitColumnBreakAfter:

1830

return cssValuePool().createValue(style->columnBreakAfter());

1831

case CSSPropertyWebkitColumnBreakBefore:

1832

return cssValuePool().createValue(style->columnBreakBefore());

1833

case CSSPropertyWebkitColumnBreakInside:

1834

return cssValuePool().createValue(style->columnBreakInside());

1835

case CSSPropertyWebkitColumnWidth:

1836

if (style->hasAutoColumnWidth())

1837

return cssValuePool().createIdentifierValue(CSSValueAuto);

1838

return zoomAdjustedPixelValue(style->columnWidth(), style.get());

1839

case CSSPropertyTabSize:

1840

return cssValuePool().createValue(style->tabSize(), CSSPrimitiveValue::CSS_NUMBER);

1841

case CSSPropertyWebkitRegionBreakAfter:

1842

return cssValuePool().createValue(style->regionBreakAfter());

1843

case CSSPropertyWebkitRegionBreakBefore:

1844

return cssValuePool().createValue(style->regionBreakBefore());

1845

case CSSPropertyWebkitRegionBreakInside:

1846

return cssValuePool().createValue(style->regionBreakInside());

1847

case CSSPropertyCursor: {

1848

RefPtr<CSSValueList> list;

1849

CursorList* cursors = style->cursors();

1850

if (cursors && cursors->size() > 0) {

1851

list = CSSValueList::createCommaSeparated();

1852

for (unsigned i = 0; i < cursors->size(); ++i)

1853

if (StyleImage* image = cursors->at(i).image())

1854

list->append(image->cssValue());

1855

}

1856

RefPtr<CSSValue> value = cssValuePool().createValue(style->cursor());

1857

if (list) {

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

1858

list->append(value.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1859

return list.release();

1860

}

1861

return value.release();

1862

}

1863

case CSSPropertyDirection:

1864

return cssValuePool().createValue(style->direction());

1865

case CSSPropertyDisplay:

1866

return cssValuePool().createValue(style->display());

1867

case CSSPropertyEmptyCells:

1868

return cssValuePool().createValue(style->emptyCells());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1869

case CSSPropertyAlignContent:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1870

return cssValuePool().createValue(style->alignContent());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1871

case CSSPropertyAlignItems:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1872

return cssValuePool().createValue(style->alignItems());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1873

case CSSPropertyAlignSelf:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1874

if (style->alignSelf() == AlignAuto) {

1875

Node* parent = styledNode->parentNode();

1876

if (parent && parent->computedStyle())

1877

return cssValuePool().createValue(parent->computedStyle()->alignItems());

1878

return cssValuePool().createValue(AlignStretch);

1879

}

1880

return cssValuePool().createValue(style->alignSelf());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1881

case CSSPropertyFlex:

1882

return getCSSPropertyValuesForShorthandProperties(flexShorthand());

1883

case CSSPropertyFlexBasis:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1884

return cssValuePool().createValue(style->flexBasis());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1885

case CSSPropertyFlexDirection:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1886

return cssValuePool().createValue(style->flexDirection());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1887

case CSSPropertyFlexFlow:

1888

return getCSSPropertyValuesForShorthandProperties(flexFlowShorthand());

1889

case CSSPropertyFlexGrow:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1890

return cssValuePool().createValue(style->flexGrow());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1891

case CSSPropertyFlexShrink:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1892

return cssValuePool().createValue(style->flexShrink());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1893

case CSSPropertyFlexWrap:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1894

return cssValuePool().createValue(style->flexWrap());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1895

case CSSPropertyJustifyContent:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1896

return cssValuePool().createValue(style->justifyContent());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1897

case CSSPropertyOrder:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1898

return cssValuePool().createValue(style->order(), CSSPrimitiveValue::CSS_NUMBER);

1899

case CSSPropertyFloat:

1900

if (style->display() != NONE && style->hasOutOfFlowPosition())

1901

return cssValuePool().createIdentifierValue(CSSValueNone);

1902

return cssValuePool().createValue(style->floating());

1903

case CSSPropertyFont: {

1904

RefPtr<FontValue> computedFont = FontValue::create();

1905

computedFont->style = fontStyleFromStyle(style.get());

1906

computedFont->variant = fontVariantFromStyle(style.get());

1907

computedFont->weight = fontWeightFromStyle(style.get());

1908

computedFont->size = fontSizeFromStyle(style.get());

1909

computedFont->lineHeight = lineHeightFromStyle(style.get(), m_node->document()->renderView());

1910

computedFont->family = fontFamilyFromStyle(style.get());

1911

return computedFont.release();

1912

}

1913

case CSSPropertyFontFamily: {

1914

RefPtr<CSSValueList> fontFamilyList = fontFamilyFromStyle(style.get());

1915

// If there's only a single family, return that as a CSSPrimitiveValue.

1916

// NOTE: Gecko always returns this as a comma-separated CSSPrimitiveValue string.

1917

if (fontFamilyList->length() == 1)

1918

return fontFamilyList->item(0);

1919

return fontFamilyList.release();

1920

}

1921

case CSSPropertyFontSize:

1922

return fontSizeFromStyle(style.get());

1923

case CSSPropertyFontStyle:

1924

return fontStyleFromStyle(style.get());

1925

case CSSPropertyFontVariant:

1926

return fontVariantFromStyle(style.get());

1927

case CSSPropertyFontWeight:

1928

return fontWeightFromStyle(style.get());

1929

case CSSPropertyWebkitFontFeatureSettings: {

1930

const FontFeatureSettings* featureSettings = style->fontDescription().featureSettings();

1931

if (!featureSettings || !featureSettings->size())

1932

return cssValuePool().createIdentifierValue(CSSValueNormal);

1933

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

1934

for (unsigned i = 0; i < featureSettings->size(); ++i) {

1935

const FontFeature& feature = featureSettings->at(i);

1936

RefPtr<FontFeatureValue> featureValue = FontFeatureValue::create(feature.tag(), feature.value());

1937

list->append(featureValue.release());

1938

}

1939

return list.release();

1940

}

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1941

case CSSPropertyGridAutoColumns:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1942

return valueForGridTrackSize(style->gridAutoColumns(), style.get(), m_node->document()->renderView());

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1943

case CSSPropertyGridAutoFlow:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1944

return cssValuePool().createValue(style->gridAutoFlow());

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1945

case CSSPropertyGridAutoRows:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1946

return valueForGridTrackSize(style->gridAutoRows(), style.get(), m_node->document()->renderView());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1947

case CSSPropertyGridDefinitionColumns:

1948

return valueForGridTrackList(style->gridDefinitionColumns(), style->namedGridColumnLines(), style.get(), m_node->document()->renderView());

1949

case CSSPropertyGridDefinitionRows:

1950

return valueForGridTrackList(style->gridDefinitionRows(), style->namedGridRowLines(), style.get(), m_node->document()->renderView());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1951

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

1952

case CSSPropertyGridColumnStart:

1953

return valueForGridPosition(style->gridColumnStart());

1954

case CSSPropertyGridColumnEnd:

1955

return valueForGridPosition(style->gridColumnEnd());

1956

case CSSPropertyGridRowStart:

1957

return valueForGridPosition(style->gridRowStart());

1958

case CSSPropertyGridRowEnd:

1959

return valueForGridPosition(style->gridRowEnd());

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

1960

case CSSPropertyGridColumn:

1961

return getCSSPropertyValuesForGridShorthand(gridColumnShorthand());

1962

case CSSPropertyGridRow:

1963

return getCSSPropertyValuesForGridShorthand(gridRowShorthand());

1964

case CSSPropertyGridArea:

1965

return getCSSPropertyValuesForGridShorthand(gridAreaShorthand());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

1966

1967

case CSSPropertyHeight:

1968

if (renderer) {

1969

// According to http://www.w3.org/TR/CSS2/visudet.html#the-height-property,

1970

// the "height" property does not apply for non-replaced inline elements.

1971

if (!renderer->isReplaced() && renderer->isInline())

1972

return cssValuePool().createIdentifierValue(CSSValueAuto);

1973

return zoomAdjustedPixelValue(sizingBox(renderer).height(), style.get());

1974

}

1975

return zoomAdjustedPixelValueForLength(style->height(), style.get());

1976

case CSSPropertyWebkitHighlight:

1977

if (style->highlight() == nullAtom)

1978

return cssValuePool().createIdentifierValue(CSSValueNone);

1979

return cssValuePool().createValue(style->highlight(), CSSPrimitiveValue::CSS_STRING);

1980

case CSSPropertyWebkitHyphens:

1981

return cssValuePool().createValue(style->hyphens());

1982

case CSSPropertyWebkitHyphenateCharacter:

1983

if (style->hyphenationString().isNull())

1984

return cssValuePool().createIdentifierValue(CSSValueAuto);

1985

return cssValuePool().createValue(style->hyphenationString(), CSSPrimitiveValue::CSS_STRING);

1986

case CSSPropertyWebkitHyphenateLimitAfter:

1987

if (style->hyphenationLimitAfter() < 0)

1988

return CSSPrimitiveValue::createIdentifier(CSSValueAuto);

1989

return CSSPrimitiveValue::create(style->hyphenationLimitAfter(), CSSPrimitiveValue::CSS_NUMBER);

1990

case CSSPropertyWebkitHyphenateLimitBefore:

1991

if (style->hyphenationLimitBefore() < 0)

1992

return CSSPrimitiveValue::createIdentifier(CSSValueAuto);

1993

return CSSPrimitiveValue::create(style->hyphenationLimitBefore(), CSSPrimitiveValue::CSS_NUMBER);

1994

case CSSPropertyWebkitHyphenateLimitLines:

1995

if (style->hyphenationLimitLines() < 0)

1996

return CSSPrimitiveValue::createIdentifier(CSSValueNoLimit);

1997

return CSSPrimitiveValue::create(style->hyphenationLimitLines(), CSSPrimitiveValue::CSS_NUMBER);

1998

case CSSPropertyWebkitBorderFit:

1999

if (style->borderFit() == BorderFitBorder)

2000

return cssValuePool().createIdentifierValue(CSSValueBorder);

2001

return cssValuePool().createIdentifierValue(CSSValueLines);

2002

case CSSPropertyImageRendering:

2003

return CSSPrimitiveValue::create(style->imageRendering());

2004

case CSSPropertyLeft:

2005

return getPositionOffsetValue(style.get(), CSSPropertyLeft, renderer, m_node->document()->renderView());

2006

case CSSPropertyLetterSpacing:

2007

if (!style->letterSpacing())

2008

return cssValuePool().createIdentifierValue(CSSValueNormal);

2009

return zoomAdjustedPixelValue(style->letterSpacing(), style.get());

2010

case CSSPropertyWebkitLineClamp:

2011

if (style->lineClamp().isNone())

2012

return cssValuePool().createIdentifierValue(CSSValueNone);

2013

return cssValuePool().createValue(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);

2014

case CSSPropertyLineHeight:

2015

return lineHeightFromStyle(style.get(), m_node->document()->renderView());

2016

case CSSPropertyListStyleImage:

2017

if (style->listStyleImage())

2018

return style->listStyleImage()->cssValue();

2019

return cssValuePool().createIdentifierValue(CSSValueNone);

2020

case CSSPropertyListStylePosition:

2021

return cssValuePool().createValue(style->listStylePosition());

2022

case CSSPropertyListStyleType:

2023

return cssValuePool().createValue(style->listStyleType());

2024

case CSSPropertyWebkitLocale:

2025

if (style->locale().isNull())

2026

return cssValuePool().createIdentifierValue(CSSValueAuto);

2027

return cssValuePool().createValue(style->locale(), CSSPrimitiveValue::CSS_STRING);

2028

case CSSPropertyMarginTop: {

2029

Length marginTop = style->marginTop();

2030

if (marginTop.isFixed() || !renderer || !renderer->isBox())

2031

return zoomAdjustedPixelValueForLength(marginTop, style.get());

2032

return zoomAdjustedPixelValue(toRenderBox(renderer)->marginTop(), style.get());

2033

}

2034

case CSSPropertyMarginRight: {

2035

Length marginRight = style->marginRight();

2036

if (marginRight.isFixed() || !renderer || !renderer->isBox())

2037

return zoomAdjustedPixelValueForLength(marginRight, style.get());

2038

float value;

2039

if (marginRight.isPercent() || marginRight.isViewportPercentage())

2040

// RenderBox gives a marginRight() that is the distance between the right-edge of the child box

2041

// and the right-edge of the containing box, when display == BLOCK. Let's calculate the absolute

2042

// value of the specified margin-right % instead of relying on RenderBox's marginRight() value.

2043

value = minimumValueForLength(marginRight, toRenderBox(renderer)->containingBlockLogicalWidthForContent(), m_node->document()->renderView());

2044

else

2045

value = toRenderBox(renderer)->marginRight();

2046

return zoomAdjustedPixelValue(value, style.get());

2047

}

2048

case CSSPropertyMarginBottom: {

2049

Length marginBottom = style->marginBottom();

2050

if (marginBottom.isFixed() || !renderer || !renderer->isBox())

2051

return zoomAdjustedPixelValueForLength(marginBottom, style.get());

2052

return zoomAdjustedPixelValue(toRenderBox(renderer)->marginBottom(), style.get());

2053

}

2054

case CSSPropertyMarginLeft: {

2055

Length marginLeft = style->marginLeft();

2056

if (marginLeft.isFixed() || !renderer || !renderer->isBox())

2057

return zoomAdjustedPixelValueForLength(marginLeft, style.get());

2058

return zoomAdjustedPixelValue(toRenderBox(renderer)->marginLeft(), style.get());

2059

}

2060

case CSSPropertyWebkitMarqueeDirection:

2061

return cssValuePool().createValue(style->marqueeDirection());

2062

case CSSPropertyWebkitMarqueeIncrement:

2063

return cssValuePool().createValue(style->marqueeIncrement());

2064

case CSSPropertyWebkitMarqueeRepetition:

2065

if (style->marqueeLoopCount() < 0)

2066

return cssValuePool().createIdentifierValue(CSSValueInfinite);

2067

return cssValuePool().createValue(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);

2068

case CSSPropertyWebkitMarqueeStyle:

2069

return cssValuePool().createValue(style->marqueeBehavior());

2070

case CSSPropertyWebkitUserModify:

2071

return cssValuePool().createValue(style->userModify());

2072

case CSSPropertyMaxHeight: {

2073

const Length& maxHeight = style->maxHeight();

2074

if (maxHeight.isUndefined())

2075

return cssValuePool().createIdentifierValue(CSSValueNone);

2076

return zoomAdjustedPixelValueForLength(maxHeight, style.get());

2077

}

2078

case CSSPropertyMaxWidth: {

2079

const Length& maxWidth = style->maxWidth();

2080

if (maxWidth.isUndefined())

2081

return cssValuePool().createIdentifierValue(CSSValueNone);

2082

return zoomAdjustedPixelValueForLength(maxWidth, style.get());

2083

}

2084

case CSSPropertyMinHeight:

2085

// FIXME: For flex-items, min-height:auto should compute to min-content.

2086

if (style->minHeight().isAuto())

2087

return zoomAdjustedPixelValue(0, style.get());

2088

return zoomAdjustedPixelValueForLength(style->minHeight(), style.get());

2089

case CSSPropertyMinWidth:

2090

// FIXME: For flex-items, min-width:auto should compute to min-content.

2091

if (style->minWidth().isAuto())

2092

return zoomAdjustedPixelValue(0, style.get());

2093

return zoomAdjustedPixelValueForLength(style->minWidth(), style.get());

2094

case CSSPropertyOpacity:

2095

return cssValuePool().createValue(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);

2096

case CSSPropertyOrphans:

2097

if (style->hasAutoOrphans())

2098

return cssValuePool().createIdentifierValue(CSSValueAuto);

2099

return cssValuePool().createValue(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);

2100

case CSSPropertyOutlineColor:

2101

return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style.get(), style->outlineColor());

2102

case CSSPropertyOutlineOffset:

2103

return zoomAdjustedPixelValue(style->outlineOffset(), style.get());

2104

case CSSPropertyOutlineStyle:

2105

if (style->outlineStyleIsAuto())

2106

return cssValuePool().createIdentifierValue(CSSValueAuto);

2107

return cssValuePool().createValue(style->outlineStyle());

2108

case CSSPropertyOutlineWidth:

2109

return zoomAdjustedPixelValue(style->outlineWidth(), style.get());

2110

case CSSPropertyOverflow:

2111

return cssValuePool().createValue(max(style->overflowX(), style->overflowY()));

2112

case CSSPropertyOverflowWrap:

2113

return cssValuePool().createValue(style->overflowWrap());

2114

case CSSPropertyOverflowX:

2115

return cssValuePool().createValue(style->overflowX());

2116

case CSSPropertyOverflowY:

2117

return cssValuePool().createValue(style->overflowY());

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

2118

case CSSPropertyPaddingTop: {

2119

Length paddingTop = style->paddingTop();

2120

if (paddingTop.isFixed() || !renderer || !renderer->isBox())

2121

return zoomAdjustedPixelValueForLength(paddingTop, style.get());

2122

return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingTop(), style.get());

2123

}

2124

case CSSPropertyPaddingRight: {

2125

Length paddingRight = style->paddingRight();

2126

if (paddingRight.isFixed() || !renderer || !renderer->isBox())

2127

return zoomAdjustedPixelValueForLength(paddingRight, style.get());

2128

return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingRight(), style.get());

2129

}

2130

case CSSPropertyPaddingBottom: {

2131

Length paddingBottom = style->paddingBottom();

2132

if (paddingBottom.isFixed() || !renderer || !renderer->isBox())

2133

return zoomAdjustedPixelValueForLength(paddingBottom, style.get());

2134

return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingBottom(), style.get());

2135

}

2136

case CSSPropertyPaddingLeft: {

2137

Length paddingLeft = style->paddingLeft();

2138

if (paddingLeft.isFixed() || !renderer || !renderer->isBox())

2139

return zoomAdjustedPixelValueForLength(paddingLeft, style.get());

2140

return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingLeft(), style.get());

2141

}

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2142

case CSSPropertyPageBreakAfter:

2143

return cssValuePool().createValue(style->pageBreakAfter());

2144

case CSSPropertyPageBreakBefore:

2145

return cssValuePool().createValue(style->pageBreakBefore());

2146

case CSSPropertyPageBreakInside: {

2147

EPageBreak pageBreak = style->pageBreakInside();

2148

ASSERT(pageBreak != PBALWAYS);

2149

if (pageBreak == PBALWAYS)

2150

return 0;

2151

return cssValuePool().createValue(style->pageBreakInside());

2152

}

2153

case CSSPropertyPosition:

2154

return cssValuePool().createValue(style->position());

2155

case CSSPropertyRight:

2156

return getPositionOffsetValue(style.get(), CSSPropertyRight, renderer, m_node->document()->renderView());

2157

case CSSPropertyWebkitRubyPosition:

2158

return cssValuePool().createValue(style->rubyPosition());

2159

case CSSPropertyTableLayout:

2160

return cssValuePool().createValue(style->tableLayout());

2161

case CSSPropertyTextAlign:

2162

return cssValuePool().createValue(style->textAlign());

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

2163

case CSSPropertyTextAlignLast:

2164

return cssValuePool().createValue(style->textAlignLast());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2165

case CSSPropertyTextDecoration:

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2166

case CSSPropertyTextDecorationLine:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2167

return renderTextDecorationFlagsToCSSValue(style->textDecoration());

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2168

case CSSPropertyTextDecorationStyle:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2169

return renderTextDecorationStyleFlagsToCSSValue(style->textDecorationStyle());

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2170

case CSSPropertyTextDecorationColor:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2171

return currentColorOrValidColor(style.get(), style->textDecorationColor());

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2172

#if ENABLE(CSS3_TEXT)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2173

case CSSPropertyWebkitTextUnderlinePosition:

2174

return cssValuePool().createValue(style->textUnderlinePosition());

2175

#endif // CSS3_TEXT

2176

case CSSPropertyWebkitTextDecorationsInEffect:

2177

return renderTextDecorationFlagsToCSSValue(style->textDecorationsInEffect());

2178

case CSSPropertyWebkitTextFillColor:

2179

return currentColorOrValidColor(style.get(), style->textFillColor());

2180

case CSSPropertyWebkitTextEmphasisColor:

2181

return currentColorOrValidColor(style.get(), style->textEmphasisColor());

2182

case CSSPropertyWebkitTextEmphasisPosition:

2183

return cssValuePool().createValue(style->textEmphasisPosition());

2184

case CSSPropertyWebkitTextEmphasisStyle:

2185

switch (style->textEmphasisMark()) {

2186

case TextEmphasisMarkNone:

2187

return cssValuePool().createIdentifierValue(CSSValueNone);

2188

case TextEmphasisMarkCustom:

2189

return cssValuePool().createValue(style->textEmphasisCustomMark(), CSSPrimitiveValue::CSS_STRING);

2190

case TextEmphasisMarkAuto:

2191

ASSERT_NOT_REACHED();

2192

// Fall through

2193

case TextEmphasisMarkDot:

2194

case TextEmphasisMarkCircle:

2195

case TextEmphasisMarkDoubleCircle:

2196

case TextEmphasisMarkTriangle:

2197

case TextEmphasisMarkSesame: {

2198

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2199

list->append(cssValuePool().createValue(style->textEmphasisFill()));

2200

list->append(cssValuePool().createValue(style->textEmphasisMark()));

2201

return list.release();

2202

}

2203

}

2204

case CSSPropertyTextIndent: {

2205

RefPtr<CSSValue> textIndent = zoomAdjustedPixelValueForLength(style->textIndent(), style.get());

2206

#if ENABLE(CSS3_TEXT)

2207

if (style->textIndentLine() == TextIndentEachLine) {

2208

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2209

list->append(textIndent.release());

2210

list->append(cssValuePool().createIdentifierValue(CSSValueWebkitEachLine));

2211

return list.release();

2212

}

2213

#endif

2214

return textIndent.release();

2215

}

2216

case CSSPropertyTextShadow:

2217

return valueForShadow(style->textShadow(), propertyID, style.get());

2218

case CSSPropertyTextRendering:

2219

return cssValuePool().createValue(style->fontDescription().textRenderingMode());

2220

case CSSPropertyTextOverflow:

2221

if (style->textOverflow())

2222

return cssValuePool().createIdentifierValue(CSSValueEllipsis);

2223

return cssValuePool().createIdentifierValue(CSSValueClip);

2224

case CSSPropertyWebkitTextSecurity:

2225

return cssValuePool().createValue(style->textSecurity());

2226

case CSSPropertyWebkitTextStrokeColor:

2227

return currentColorOrValidColor(style.get(), style->textStrokeColor());

2228

case CSSPropertyWebkitTextStrokeWidth:

2229

return zoomAdjustedPixelValue(style->textStrokeWidth(), style.get());

2230

case CSSPropertyTextTransform:

2231

return cssValuePool().createValue(style->textTransform());

2232

case CSSPropertyTop:

2233

return getPositionOffsetValue(style.get(), CSSPropertyTop, renderer, m_node->document()->renderView());

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2234

case CSSPropertyTouchAction:

2235

return cssValuePool().createValue(style->touchAction());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2236

case CSSPropertyUnicodeBidi:

2237

return cssValuePool().createValue(style->unicodeBidi());

2238

case CSSPropertyVerticalAlign:

2239

switch (style->verticalAlign()) {

2240

case BASELINE:

2241

return cssValuePool().createIdentifierValue(CSSValueBaseline);

2242

case MIDDLE:

2243

return cssValuePool().createIdentifierValue(CSSValueMiddle);

2244

case SUB:

2245

return cssValuePool().createIdentifierValue(CSSValueSub);

2246

case SUPER:

2247

return cssValuePool().createIdentifierValue(CSSValueSuper);

2248

case TEXT_TOP:

2249

return cssValuePool().createIdentifierValue(CSSValueTextTop);

2250

case TEXT_BOTTOM:

2251

return cssValuePool().createIdentifierValue(CSSValueTextBottom);

2252

case TOP:

2253

return cssValuePool().createIdentifierValue(CSSValueTop);

2254

case BOTTOM:

2255

return cssValuePool().createIdentifierValue(CSSValueBottom);

2256

case BASELINE_MIDDLE:

2257

return cssValuePool().createIdentifierValue(CSSValueWebkitBaselineMiddle);

2258

case LENGTH:

2259

return cssValuePool().createValue(style->verticalAlignLength());

2260

}

2261

ASSERT_NOT_REACHED();

2262

return 0;

2263

case CSSPropertyVisibility:

2264

return cssValuePool().createValue(style->visibility());

2265

case CSSPropertyWhiteSpace:

2266

return cssValuePool().createValue(style->whiteSpace());

2267

case CSSPropertyWidows:

2268

if (style->hasAutoWidows())

2269

return cssValuePool().createIdentifierValue(CSSValueAuto);

2270

return cssValuePool().createValue(style->widows(), CSSPrimitiveValue::CSS_NUMBER);

2271

case CSSPropertyWidth:

2272

if (renderer) {

2273

// According to http://www.w3.org/TR/CSS2/visudet.html#the-width-property,

2274

// the "width" property does not apply for non-replaced inline elements.

2275

if (!renderer->isReplaced() && renderer->isInline())

2276

return cssValuePool().createIdentifierValue(CSSValueAuto);

2277

return zoomAdjustedPixelValue(sizingBox(renderer).width(), style.get());

2278

}

2279

return zoomAdjustedPixelValueForLength(style->width(), style.get());

2280

case CSSPropertyWordBreak:

2281

return cssValuePool().createValue(style->wordBreak());

2282

case CSSPropertyWordSpacing:

2283

return zoomAdjustedPixelValue(style->wordSpacing(), style.get());

2284

case CSSPropertyWordWrap:

2285

return cssValuePool().createValue(style->overflowWrap());

2286

case CSSPropertyWebkitLineBreak:

2287

return cssValuePool().createValue(style->lineBreak());

2288

case CSSPropertyResize:

2289

return cssValuePool().createValue(style->resize());

2290

case CSSPropertyWebkitFontKerning:

2291

return cssValuePool().createValue(style->fontDescription().kerning());

2292

case CSSPropertyWebkitFontSmoothing:

2293

return cssValuePool().createValue(style->fontDescription().fontSmoothing());

2294

case CSSPropertyWebkitFontVariantLigatures: {

2295

FontDescription::LigaturesState commonLigaturesState = style->fontDescription().commonLigaturesState();

2296

FontDescription::LigaturesState discretionaryLigaturesState = style->fontDescription().discretionaryLigaturesState();

2297

FontDescription::LigaturesState historicalLigaturesState = style->fontDescription().historicalLigaturesState();

2298

if (commonLigaturesState == FontDescription::NormalLigaturesState && discretionaryLigaturesState == FontDescription::NormalLigaturesState

2299

&& historicalLigaturesState == FontDescription::NormalLigaturesState)

2300

return cssValuePool().createIdentifierValue(CSSValueNormal);

2301

2302

RefPtr<CSSValueList> valueList = CSSValueList::createSpaceSeparated();

2303

if (commonLigaturesState != FontDescription::NormalLigaturesState)

2304

valueList->append(cssValuePool().createIdentifierValue(commonLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoCommonLigatures : CSSValueCommonLigatures));

2305

if (discretionaryLigaturesState != FontDescription::NormalLigaturesState)

2306

valueList->append(cssValuePool().createIdentifierValue(discretionaryLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoDiscretionaryLigatures : CSSValueDiscretionaryLigatures));

2307

if (historicalLigaturesState != FontDescription::NormalLigaturesState)

2308

valueList->append(cssValuePool().createIdentifierValue(historicalLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoHistoricalLigatures : CSSValueHistoricalLigatures));

2309

return valueList;

2310

}

2311

case CSSPropertyZIndex:

2312

if (style->hasAutoZIndex())

2313

return cssValuePool().createIdentifierValue(CSSValueAuto);

2314

return cssValuePool().createValue(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);

2315

case CSSPropertyZoom:

2316

return cssValuePool().createValue(style->zoom(), CSSPrimitiveValue::CSS_NUMBER);

2317

case CSSPropertyBoxSizing:

2318

if (style->boxSizing() == CONTENT_BOX)

2319

return cssValuePool().createIdentifierValue(CSSValueContentBox);

2320

return cssValuePool().createIdentifierValue(CSSValueBorderBox);

2321

case CSSPropertyWebkitAppRegion:

2322

return cssValuePool().createIdentifierValue(style->getDraggableRegionMode() == DraggableRegionDrag ? CSSValueDrag : CSSValueNoDrag);

2323

case CSSPropertyWebkitAnimationDelay:

2324

return getDelayValue(style->animations());

2325

case CSSPropertyWebkitAnimationDirection: {

2326

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

2327

const CSSAnimationDataList* t = style->animations();

2328

if (t) {

2329

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

2330

if (t->animation(i)->direction())

2331

list->append(cssValuePool().createIdentifierValue(CSSValueAlternate));

2332

else

2333

list->append(cssValuePool().createIdentifierValue(CSSValueNormal));

2334

}

2335

} else

2336

list->append(cssValuePool().createIdentifierValue(CSSValueNormal));

2337

return list.release();

2338

}

2339

case CSSPropertyWebkitAnimationDuration:

2340

return getDurationValue(style->animations());

2341

case CSSPropertyWebkitAnimationFillMode: {

2342

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

2343

const CSSAnimationDataList* t = style->animations();

2344

if (t) {

2345

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

2346

switch (t->animation(i)->fillMode()) {

2347

case AnimationFillModeNone:

2348

list->append(cssValuePool().createIdentifierValue(CSSValueNone));

2349

break;

2350

case AnimationFillModeForwards:

2351

list->append(cssValuePool().createIdentifierValue(CSSValueForwards));

2352

break;

2353

case AnimationFillModeBackwards:

2354

list->append(cssValuePool().createIdentifierValue(CSSValueBackwards));

2355

break;

2356

case AnimationFillModeBoth:

2357

list->append(cssValuePool().createIdentifierValue(CSSValueBoth));

break;

}

}

} else

list->append(cssValuePool().createIdentifierValue(CSSValueNone));

2363

return list.release();

2364

}

2365

case CSSPropertyWebkitAnimationIterationCount: {

2366

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

2367

const CSSAnimationDataList* t = style->animations();

2368

if (t) {

2369

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

2370

double iterationCount = t->animation(i)->iterationCount();

2371

if (iterationCount == CSSAnimationData::IterationCountInfinite)

2372

list->append(cssValuePool().createIdentifierValue(CSSValueInfinite));

2373

else

2374

list->append(cssValuePool().createValue(iterationCount, CSSPrimitiveValue::CSS_NUMBER));

2375

}

2376

} else

2377

list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));

2378

return list.release();

2379

}

2380

case CSSPropertyWebkitAnimationName: {

2381

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

2382

const CSSAnimationDataList* t = style->animations();

2383

if (t) {

2384

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

2385

list->append(cssValuePool().createValue(t->animation(i)->name(), CSSPrimitiveValue::CSS_STRING));

2386

} else

2387

list->append(cssValuePool().createIdentifierValue(CSSValueNone));

2388

return list.release();

2389

}

2390

case CSSPropertyWebkitAnimationPlayState: {

2391

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

2392

const CSSAnimationDataList* t = style->animations();

2393

if (t) {

2394

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

2395

int prop = t->animation(i)->playState();

2396

if (prop == AnimPlayStatePlaying)

2397

list->append(cssValuePool().createIdentifierValue(CSSValueRunning));

2398

else

2399

list->append(cssValuePool().createIdentifierValue(CSSValuePaused));

2400

}

2401

} else

2402

list->append(cssValuePool().createIdentifierValue(CSSValueRunning));

2403

return list.release();

2404

}

2405

case CSSPropertyWebkitAnimationTimingFunction:

2406

return getTimingFunctionValue(style->animations());

2407

case CSSPropertyWebkitAppearance:

2408

return cssValuePool().createValue(style->appearance());

2409

case CSSPropertyWebkitAspectRatio:

2410

if (!style->hasAspectRatio())

2411

return cssValuePool().createIdentifierValue(CSSValueNone);

2412

return CSSAspectRatioValue::create(style->aspectRatioNumerator(), style->aspectRatioDenominator());

2413

case CSSPropertyWebkitBackfaceVisibility:

2414

return cssValuePool().createIdentifierValue((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);

2415

case CSSPropertyWebkitBorderImage:

2416

return valueForNinePieceImage(style->borderImage());

2417

case CSSPropertyBorderImageOutset:

2418

return valueForNinePieceImageQuad(style->borderImage().outset());

2419

case CSSPropertyBorderImageRepeat:

2420

return valueForNinePieceImageRepeat(style->borderImage());

2421

case CSSPropertyBorderImageSlice:

2422

return valueForNinePieceImageSlice(style->borderImage());

2423

case CSSPropertyBorderImageWidth:

2424

return valueForNinePieceImageQuad(style->borderImage().borderSlices());

2425

case CSSPropertyWebkitMaskBoxImage:

2426

return valueForNinePieceImage(style->maskBoxImage());

2427

case CSSPropertyWebkitMaskBoxImageOutset:

2428

return valueForNinePieceImageQuad(style->maskBoxImage().outset());

2429

case CSSPropertyWebkitMaskBoxImageRepeat:

2430

return valueForNinePieceImageRepeat(style->maskBoxImage());

2431

case CSSPropertyWebkitMaskBoxImageSlice:

2432

return valueForNinePieceImageSlice(style->maskBoxImage());

2433

case CSSPropertyWebkitMaskBoxImageWidth:

2434

return valueForNinePieceImageQuad(style->maskBoxImage().borderSlices());

2435

case CSSPropertyWebkitMaskBoxImageSource:

2436

if (style->maskBoxImageSource())

2437

return style->maskBoxImageSource()->cssValue();

2438

return cssValuePool().createIdentifierValue(CSSValueNone);

2439

case CSSPropertyWebkitFontSizeDelta:

2440

// Not a real style property -- used by the editing engine -- so has no computed value.

2441

break;

2442

case CSSPropertyWebkitMarginBottomCollapse:

2443

case CSSPropertyWebkitMarginAfterCollapse:

2444

return cssValuePool().createValue(style->marginAfterCollapse());

2445

case CSSPropertyWebkitMarginTopCollapse:

2446

case CSSPropertyWebkitMarginBeforeCollapse:

2447

return cssValuePool().createValue(style->marginBeforeCollapse());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2448

case CSSPropertyWebkitPerspective:

2449

if (!style->hasPerspective())

2450

return cssValuePool().createIdentifierValue(CSSValueNone);

2451

return zoomAdjustedPixelValue(style->perspective(), style.get());

2452

case CSSPropertyWebkitPerspectiveOrigin: {

2453

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2454

if (renderer) {

2455

LayoutRect box;

2456

if (renderer->isBox())

2457

box = toRenderBox(renderer)->borderBoxRect();

2458

2459

RenderView* renderView = m_node->document()->renderView();

2460

list->append(zoomAdjustedPixelValue(minimumValueForLength(style->perspectiveOriginX(), box.width(), renderView), style.get()));

2461

list->append(zoomAdjustedPixelValue(minimumValueForLength(style->perspectiveOriginY(), box.height(), renderView), style.get()));

2462

}

2463

else {

2464

list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginX(), style.get()));

2465

list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginY(), style.get()));

2466

2467

}

2468

return list.release();

2469

}

2470

case CSSPropertyWebkitRtlOrdering:

2471

return cssValuePool().createIdentifierValue(style->rtlOrdering() ? CSSValueVisual : CSSValueLogical);

2472

case CSSPropertyWebkitTapHighlightColor:

2473

return currentColorOrValidColor(style.get(), style->tapHighlightColor());

2474

case CSSPropertyWebkitUserDrag:

2475

return cssValuePool().createValue(style->userDrag());

2476

case CSSPropertyWebkitUserSelect:

2477

return cssValuePool().createValue(style->userSelect());

2478

case CSSPropertyBorderBottomLeftRadius:

2479

return getBorderRadiusCornerValue(style->borderBottomLeftRadius(), style.get(), m_node->document()->renderView());

2480

case CSSPropertyBorderBottomRightRadius:

2481

return getBorderRadiusCornerValue(style->borderBottomRightRadius(), style.get(), m_node->document()->renderView());

2482

case CSSPropertyBorderTopLeftRadius:

2483

return getBorderRadiusCornerValue(style->borderTopLeftRadius(), style.get(), m_node->document()->renderView());

2484

case CSSPropertyBorderTopRightRadius:

2485

return getBorderRadiusCornerValue(style->borderTopRightRadius(), style.get(), m_node->document()->renderView());

2486

case CSSPropertyClip: {

2487

if (!style->hasClip())

2488

return cssValuePool().createIdentifierValue(CSSValueAuto);

2489

RefPtr<Rect> rect = Rect::create();

2490

rect->setTop(zoomAdjustedPixelValue(style->clip().top().value(), style.get()));

2491

rect->setRight(zoomAdjustedPixelValue(style->clip().right().value(), style.get()));

2492

rect->setBottom(zoomAdjustedPixelValue(style->clip().bottom().value(), style.get()));

2493

rect->setLeft(zoomAdjustedPixelValue(style->clip().left().value(), style.get()));

2494

return cssValuePool().createValue(rect.release());

2495

}

2496

case CSSPropertySpeak:

2497

return cssValuePool().createValue(style->speak());

2498

case CSSPropertyWebkitTransform:

2499

return computedTransform(renderer, style.get());

2500

case CSSPropertyWebkitTransformOrigin: {

2501

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2502

if (renderer) {

2503

LayoutRect box;

2504

if (renderer->isBox())

2505

box = toRenderBox(renderer)->borderBoxRect();

2506

2507

RenderView* renderView = m_node->document()->renderView();

2508

list->append(zoomAdjustedPixelValue(minimumValueForLength(style->transformOriginX(), box.width(), renderView), style.get()));

2509

list->append(zoomAdjustedPixelValue(minimumValueForLength(style->transformOriginY(), box.height(), renderView), style.get()));

2510

if (style->transformOriginZ() != 0)

2511

list->append(zoomAdjustedPixelValue(style->transformOriginZ(), style.get()));

2512

} else {

2513

list->append(zoomAdjustedPixelValueForLength(style->transformOriginX(), style.get()));

2514

list->append(zoomAdjustedPixelValueForLength(style->transformOriginY(), style.get()));

2515

if (style->transformOriginZ() != 0)

2516

list->append(zoomAdjustedPixelValue(style->transformOriginZ(), style.get()));

2517

}

2518

return list.release();

2519

}

2520

case CSSPropertyWebkitTransformStyle:

2521

return cssValuePool().createIdentifierValue((style->transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);

2522

case CSSPropertyTransitionDelay:

2523

case CSSPropertyWebkitTransitionDelay:

2524

return getDelayValue(style->transitions());

2525

case CSSPropertyTransitionDuration:

2526

case CSSPropertyWebkitTransitionDuration:

2527

return getDurationValue(style->transitions());

2528

case CSSPropertyTransitionProperty:

2529

case CSSPropertyWebkitTransitionProperty:

2530

return getTransitionPropertyValue(style->transitions());

2531

case CSSPropertyTransitionTimingFunction:

2532

case CSSPropertyWebkitTransitionTimingFunction:

2533

return getTimingFunctionValue(style->transitions());

2534

case CSSPropertyTransition:

2535

case CSSPropertyWebkitTransition: {

2536

const CSSAnimationDataList* animList = style->transitions();

2537

if (animList) {

2538

RefPtr<CSSValueList> transitionsList = CSSValueList::createCommaSeparated();

2539

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

2540

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2541

const CSSAnimationData* animation = animList->animation(i);

2542

list->append(createTransitionPropertyValue(animation));

2543

list->append(cssValuePool().createValue(animation->duration(), CSSPrimitiveValue::CSS_S));

2544

list->append(createTimingFunctionValue(animation->timingFunction().get()));

2545

list->append(cssValuePool().createValue(animation->delay(), CSSPrimitiveValue::CSS_S));

2546

transitionsList->append(list);

2547

}

2548

return transitionsList.release();

2549

}

2550

2551

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2552

// transition-property default value.

2553

list->append(cssValuePool().createIdentifierValue(CSSValueAll));

2554

list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));

2555

list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));

2556

list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));

2557

return list.release();

2558

}

2559

case CSSPropertyPointerEvents:

2560

return cssValuePool().createValue(style->pointerEvents());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2561

case CSSPropertyWebkitLineGrid:

2562

if (style->lineGrid().isNull())

2563

return cssValuePool().createIdentifierValue(CSSValueNone);

2564

return cssValuePool().createValue(style->lineGrid(), CSSPrimitiveValue::CSS_STRING);

2565

case CSSPropertyWebkitLineSnap:

2566

return CSSPrimitiveValue::create(style->lineSnap());

2567

case CSSPropertyWebkitLineAlign:

2568

return CSSPrimitiveValue::create(style->lineAlign());

2569

case CSSPropertyWebkitWritingMode:

2570

return cssValuePool().createValue(style->writingMode());

2571

case CSSPropertyWebkitTextCombine:

2572

return cssValuePool().createValue(style->textCombine());

2573

case CSSPropertyWebkitTextOrientation:

2574

return CSSPrimitiveValue::create(style->textOrientation());

2575

case CSSPropertyWebkitLineBoxContain:

2576

return createLineBoxContainValue(style->lineBoxContain());

2577

case CSSPropertyContent:

2578

return contentToCSSValue(style.get());

2579

case CSSPropertyCounterIncrement:

2580

return counterToCSSValue(style.get(), propertyID);

2581

case CSSPropertyCounterReset:

2582

return counterToCSSValue(style.get(), propertyID);

2583

case CSSPropertyWebkitClipPath:

2584

if (ClipPathOperation* operation = style->clipPath()) {

2585

if (operation->getOperationType() == ClipPathOperation::SHAPE)

2586

return valueForBasicShape(static_cast<ShapeClipPathOperation*>(operation)->basicShape());

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2587

if (operation->getOperationType() == ClipPathOperation::REFERENCE) {

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2588

ReferenceClipPathOperation* referenceOperation = static_cast<ReferenceClipPathOperation*>(operation);

2589

return CSSPrimitiveValue::create(referenceOperation->url(), CSSPrimitiveValue::CSS_URI);

2590

}

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2591

}

2592

return cssValuePool().createIdentifierValue(CSSValueNone);

2593

case CSSPropertyWebkitFlowInto:

2594

if (style->flowThread().isNull())

2595

return cssValuePool().createIdentifierValue(CSSValueNone);

2596

return cssValuePool().createValue(style->flowThread(), CSSPrimitiveValue::CSS_STRING);

2597

case CSSPropertyWebkitFlowFrom:

2598

if (style->regionThread().isNull())

2599

return cssValuePool().createIdentifierValue(CSSValueNone);

2600

return cssValuePool().createValue(style->regionThread(), CSSPrimitiveValue::CSS_STRING);

Torne (Richard Coles)

521d96e

2013-06-19 11:58:24 +0100

[diff] [blame]

2601

case CSSPropertyWebkitRegionFragment:

2602

return cssValuePool().createValue(style->regionFragment());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2603

case CSSPropertyWebkitWrapFlow:

2604

return cssValuePool().createValue(style->wrapFlow());

2605

case CSSPropertyWebkitShapeMargin:

2606

return cssValuePool().createValue(style->shapeMargin());

2607

case CSSPropertyWebkitShapePadding:

2608

return cssValuePool().createValue(style->shapePadding());

2609

case CSSPropertyWebkitShapeInside:

2610

if (!style->shapeInside())

2611

return cssValuePool().createIdentifierValue(CSSValueAuto);

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

2612

if (style->shapeInside()->type() == ShapeValue::Outside)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2613

return cssValuePool().createIdentifierValue(CSSValueOutsideShape);

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

2614

if (style->shapeInside()->type() == ShapeValue::Image) {

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2615

if (style->shapeInside()->image())

2616

return style->shapeInside()->image()->cssValue();

2617

return cssValuePool().createIdentifierValue(CSSValueNone);

2618

}

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

2619

ASSERT(style->shapeInside()->type() == ShapeValue::Shape);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2620

return valueForBasicShape(style->shapeInside()->shape());

2621

case CSSPropertyWebkitShapeOutside:

2622

if (!style->shapeOutside())

2623

return cssValuePool().createIdentifierValue(CSSValueAuto);

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

2624

if (style->shapeOutside()->type() == ShapeValue::Image) {

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2625

if (style->shapeOutside()->image())

2626

return style->shapeOutside()->image()->cssValue();

2627

return cssValuePool().createIdentifierValue(CSSValueNone);

2628

}

Ben Murdoch

2013-07-10 11:41:44 +0100

[diff] [blame]

2629

ASSERT(style->shapeOutside()->type() == ShapeValue::Shape);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2630

return valueForBasicShape(style->shapeOutside()->shape());

2631

case CSSPropertyWebkitWrapThrough:

2632

return cssValuePool().createValue(style->wrapThrough());

2633

case CSSPropertyWebkitFilter:

2634

return valueForFilter(renderer, style.get());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2635

case CSSPropertyMixBlendMode:

2636

return cssValuePool().createValue(style->blendMode());

2637

2638

case CSSPropertyBackgroundBlendMode: {

2639

const FillLayer* layers = style->backgroundLayers();

2640

if (!layers->next())

2641

return cssValuePool().createValue(layers->blendMode());

2642

2643

RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();

2644

for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())

2645

list->append(cssValuePool().createValue(currLayer->blendMode()));

2646

2647

return list.release();

2648

}

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2649

case CSSPropertyBackground:

2650

return getBackgroundShorthandValue();

2651

case CSSPropertyBorder: {

2652

RefPtr<CSSValue> value = getPropertyCSSValue(CSSPropertyBorderTop, DoNotUpdateLayout);

2653

const CSSPropertyID properties[3] = { CSSPropertyBorderRight, CSSPropertyBorderBottom,

2654

CSSPropertyBorderLeft };

2655

for (size_t i = 0; i < WTF_ARRAY_LENGTH(properties); ++i) {

2656

if (!compareCSSValuePtr<CSSValue>(value, getPropertyCSSValue(properties[i], DoNotUpdateLayout)))

2657

return 0;

2658

}

2659

return value.release();

2660

}

2661

case CSSPropertyBorderBottom:

2662

return getCSSPropertyValuesForShorthandProperties(borderBottomShorthand());

2663

case CSSPropertyBorderColor:

2664

return getCSSPropertyValuesForSidesShorthand(borderColorShorthand());

2665

case CSSPropertyBorderLeft:

2666

return getCSSPropertyValuesForShorthandProperties(borderLeftShorthand());

2667

case CSSPropertyBorderImage:

2668

return valueForNinePieceImage(style->borderImage());

2669

case CSSPropertyBorderRadius:

2670

return getBorderRadiusShorthandValue(style.get(), m_node->document()->renderView());

2671

case CSSPropertyBorderRight:

2672

return getCSSPropertyValuesForShorthandProperties(borderRightShorthand());

2673

case CSSPropertyBorderStyle:

2674

return getCSSPropertyValuesForSidesShorthand(borderStyleShorthand());

2675

case CSSPropertyBorderTop:

2676

return getCSSPropertyValuesForShorthandProperties(borderTopShorthand());

2677

case CSSPropertyBorderWidth:

2678

return getCSSPropertyValuesForSidesShorthand(borderWidthShorthand());

2679

case CSSPropertyWebkitColumnRule:

2680

return getCSSPropertyValuesForShorthandProperties(webkitColumnRuleShorthand());

2681

case CSSPropertyWebkitColumns:

2682

return getCSSPropertyValuesForShorthandProperties(webkitColumnsShorthand());

2683

case CSSPropertyListStyle:

2684

return getCSSPropertyValuesForShorthandProperties(listStyleShorthand());

2685

case CSSPropertyMargin:

2686

return getCSSPropertyValuesForSidesShorthand(marginShorthand());

2687

case CSSPropertyOutline:

2688

return getCSSPropertyValuesForShorthandProperties(outlineShorthand());

2689

case CSSPropertyPadding:

2690

return getCSSPropertyValuesForSidesShorthand(paddingShorthand());

2691

/* Individual properties not part of the spec */

2692

case CSSPropertyBackgroundRepeatX:

2693

case CSSPropertyBackgroundRepeatY:

2694

break;

2695

2696

/* Unimplemented CSS 3 properties (including CSS3 shorthand properties) */

2697

case CSSPropertyWebkitTextEmphasis:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2698

case CSSPropertyTextLineThroughColor:

2699

case CSSPropertyTextLineThroughMode:

2700

case CSSPropertyTextLineThroughStyle:

2701

case CSSPropertyTextLineThroughWidth:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2702

case CSSPropertyTextOverlineColor:

2703

case CSSPropertyTextOverlineMode:

2704

case CSSPropertyTextOverlineStyle:

2705

case CSSPropertyTextOverlineWidth:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2706

case CSSPropertyTextUnderlineColor:

2707

case CSSPropertyTextUnderlineMode:

2708

case CSSPropertyTextUnderlineStyle:

2709

case CSSPropertyTextUnderlineWidth:

2710

break;

2711

2712

/* Directional properties are resolved by resolveDirectionAwareProperty() before the switch. */

2713

case CSSPropertyWebkitBorderEnd:

2714

case CSSPropertyWebkitBorderEndColor:

2715

case CSSPropertyWebkitBorderEndStyle:

2716

case CSSPropertyWebkitBorderEndWidth:

2717

case CSSPropertyWebkitBorderStart:

2718

case CSSPropertyWebkitBorderStartColor:

2719

case CSSPropertyWebkitBorderStartStyle:

2720

case CSSPropertyWebkitBorderStartWidth:

2721

case CSSPropertyWebkitBorderAfter:

2722

case CSSPropertyWebkitBorderAfterColor:

2723

case CSSPropertyWebkitBorderAfterStyle:

2724

case CSSPropertyWebkitBorderAfterWidth:

2725

case CSSPropertyWebkitBorderBefore:

2726

case CSSPropertyWebkitBorderBeforeColor:

2727

case CSSPropertyWebkitBorderBeforeStyle:

2728

case CSSPropertyWebkitBorderBeforeWidth:

2729

case CSSPropertyWebkitMarginEnd:

2730

case CSSPropertyWebkitMarginStart:

2731

case CSSPropertyWebkitMarginAfter:

2732

case CSSPropertyWebkitMarginBefore:

2733

case CSSPropertyWebkitPaddingEnd:

2734

case CSSPropertyWebkitPaddingStart:

2735

case CSSPropertyWebkitPaddingAfter:

2736

case CSSPropertyWebkitPaddingBefore:

2737

case CSSPropertyWebkitLogicalWidth:

2738

case CSSPropertyWebkitLogicalHeight:

2739

case CSSPropertyWebkitMinLogicalWidth:

2740

case CSSPropertyWebkitMinLogicalHeight:

2741

case CSSPropertyWebkitMaxLogicalWidth:

2742

case CSSPropertyWebkitMaxLogicalHeight:

2743

ASSERT_NOT_REACHED();

2744

break;

2745

2746

/* Unimplemented @font-face properties */

2747

case CSSPropertyFontStretch:

2748

case CSSPropertySrc:

2749

case CSSPropertyUnicodeRange:

2750

break;

2751

2752

/* Other unimplemented properties */

2753

case CSSPropertyPage: // for @page

2754

case CSSPropertyQuotes: // FIXME: needs implementation

2755

case CSSPropertySize: // for @page

2756

break;

2757

2758

/* Unimplemented -webkit- properties */

2759

case CSSPropertyWebkitAnimation:

2760

case CSSPropertyWebkitBorderRadius:

2761

case CSSPropertyWebkitMarginCollapse:

2762

case CSSPropertyWebkitMarquee:

2763

case CSSPropertyWebkitMarqueeSpeed:

2764

case CSSPropertyWebkitMask:

2765

case CSSPropertyWebkitMaskRepeatX:

2766

case CSSPropertyWebkitMaskRepeatY:

2767

case CSSPropertyWebkitPerspectiveOriginX:

2768

case CSSPropertyWebkitPerspectiveOriginY:

2769

case CSSPropertyWebkitTextStroke:

2770

case CSSPropertyWebkitTransformOriginX:

2771

case CSSPropertyWebkitTransformOriginY:

2772

case CSSPropertyWebkitTransformOriginZ:

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2773

break;

2774

Torne (Richard Coles)

521d96e

2013-06-19 11:58:24 +0100

[diff] [blame]

2775

/* @viewport rule properties */

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2776

case CSSPropertyMaxZoom:

2777

case CSSPropertyMinZoom:

2778

case CSSPropertyOrientation:

2779

case CSSPropertyUserZoom:

2780

break;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2781

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2782

case CSSPropertyBufferedRendering:

2783

case CSSPropertyClipPath:

2784

case CSSPropertyClipRule:

2785

case CSSPropertyMask:

2786

case CSSPropertyEnableBackground:

2787

case CSSPropertyFilter:

2788

case CSSPropertyFloodColor:

2789

case CSSPropertyFloodOpacity:

2790

case CSSPropertyLightingColor:

2791

case CSSPropertyStopColor:

2792

case CSSPropertyStopOpacity:

2793

case CSSPropertyColorInterpolation:

2794

case CSSPropertyColorInterpolationFilters:

2795

case CSSPropertyColorProfile:

2796

case CSSPropertyColorRendering:

2797

case CSSPropertyFill:

2798

case CSSPropertyFillOpacity:

2799

case CSSPropertyFillRule:

2800

case CSSPropertyMarker:

2801

case CSSPropertyMarkerEnd:

2802

case CSSPropertyMarkerMid:

2803

case CSSPropertyMarkerStart:

2804

case CSSPropertyMaskType:

2805

case CSSPropertyShapeRendering:

2806

case CSSPropertyStroke:

2807

case CSSPropertyStrokeDasharray:

2808

case CSSPropertyStrokeDashoffset:

2809

case CSSPropertyStrokeLinecap:

2810

case CSSPropertyStrokeLinejoin:

2811

case CSSPropertyStrokeMiterlimit:

2812

case CSSPropertyStrokeOpacity:

2813

case CSSPropertyStrokeWidth:

2814

case CSSPropertyAlignmentBaseline:

2815

case CSSPropertyBaselineShift:

2816

case CSSPropertyDominantBaseline:

2817

case CSSPropertyGlyphOrientationHorizontal:

2818

case CSSPropertyGlyphOrientationVertical:

2819

case CSSPropertyKerning:

2820

case CSSPropertyTextAnchor:

2821

case CSSPropertyVectorEffect:

2822

case CSSPropertyWritingMode:

2823

case CSSPropertyWebkitSvgShadow:

2824

return getSVGPropertyCSSValue(propertyID, DoNotUpdateLayout);

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2825

}

2826

2827

logUnimplementedPropertyID(propertyID);

return 0;

}

String CSSComputedStyleDeclaration::getPropertyValue(CSSPropertyID propertyID) const

2832

{

2833

RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);

2834

if (value)

2835

return value->cssText();

return "";

}

unsigned CSSComputedStyleDeclaration::length() const

2841

{

2842

Node* node = m_node.get();

if (!node)

return 0;

RenderStyle* style = node->computedStyle(m_pseudoElementSpecifier);

if (!style)

return 0;

return computableProperties().size();

2851

}

2852

2853

String CSSComputedStyleDeclaration::item(unsigned i) const

{

if (i >= length())

return "";

return getPropertyNameString(computableProperties()[i]);

2859

}

2860

2861

bool CSSComputedStyleDeclaration::cssPropertyMatches(CSSPropertyID propertyID, const CSSValue* propertyValue) const

2862

{

2863

if (propertyID == CSSPropertyFontSize && propertyValue->isPrimitiveValue() && m_node) {

2864

m_node->document()->updateLayoutIgnorePendingStylesheets();

2865

RenderStyle* style = m_node->computedStyle(m_pseudoElementSpecifier);

2866

if (style && style->fontDescription().keywordSize()) {

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2867

CSSValueID sizeValue = cssIdentifierForFontSizeKeyword(style->fontDescription().keywordSize());

Torne (Richard Coles)

e524955

2013-05-15 11:35:13 +0100

[diff] [blame]

2868

const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(propertyValue);

Torne (Richard Coles)

2013-06-11 10:57:24 +0100

[diff] [blame]

2869

if (primitiveValue->isValueID() && primitiveValue->getValueID() == sizeValue)

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

return true;

}

}

RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);

2874

return value && propertyValue && value->equals(*propertyValue);

2875

}

2876

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2877

PassRefPtr<MutableStylePropertySet> CSSComputedStyleDeclaration::copyProperties() const

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2878

{

2879

return copyPropertiesInSet(computableProperties());

2880

}

2881

2882

PassRefPtr<CSSValueList> CSSComputedStyleDeclaration::getCSSPropertyValuesForShorthandProperties(const StylePropertyShorthand& shorthand) const

2883

{

2884

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2885

for (size_t i = 0; i < shorthand.length(); ++i) {

2886

RefPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i], DoNotUpdateLayout);

2887

list->append(value);

2888

}

2889

return list.release();

2890

}

2891

2892

PassRefPtr<CSSValueList> CSSComputedStyleDeclaration::getCSSPropertyValuesForSidesShorthand(const StylePropertyShorthand& shorthand) const

2893

{

2894

RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();

2895

// Assume the properties are in the usual order top, right, bottom, left.

2896

RefPtr<CSSValue> topValue = getPropertyCSSValue(shorthand.properties()[0], DoNotUpdateLayout);

2897

RefPtr<CSSValue> rightValue = getPropertyCSSValue(shorthand.properties()[1], DoNotUpdateLayout);

2898

RefPtr<CSSValue> bottomValue = getPropertyCSSValue(shorthand.properties()[2], DoNotUpdateLayout);

2899

RefPtr<CSSValue> leftValue = getPropertyCSSValue(shorthand.properties()[3], DoNotUpdateLayout);

2900

2901

// All 4 properties must be specified.

2902

if (!topValue || !rightValue || !bottomValue || !leftValue)

2903

return 0;

2904

2905

bool showLeft = !compareCSSValuePtr(rightValue, leftValue);

2906

bool showBottom = !compareCSSValuePtr(topValue, bottomValue) || showLeft;

2907

bool showRight = !compareCSSValuePtr(topValue, rightValue) || showBottom;

2908

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2909

list->append(topValue.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2910

if (showRight)

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2911

list->append(rightValue.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2912

if (showBottom)

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2913

list->append(bottomValue.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2914

if (showLeft)

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2915

list->append(leftValue.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2916

2917

return list.release();

2918

}

2919

2920

PassRefPtr<CSSValueList> CSSComputedStyleDeclaration::getCSSPropertyValuesForGridShorthand(const StylePropertyShorthand& shorthand) const

2921

{

2922

RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();

2923

for (size_t i = 0; i < shorthand.length(); ++i) {

2924

RefPtr<CSSValue> value = getPropertyCSSValue(shorthand.properties()[i], DoNotUpdateLayout);

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2925

list->append(value.release());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2926

}

2927

return list.release();

2928

}

2929

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2930

PassRefPtr<MutableStylePropertySet> CSSComputedStyleDeclaration::copyPropertiesInSet(const Vector<CSSPropertyID>& properties) const

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2931

{

2932

Vector<CSSProperty, 256> list;

2933

list.reserveInitialCapacity(properties.size());

2934

for (unsigned i = 0; i < properties.size(); ++i) {

2935

RefPtr<CSSValue> value = getPropertyCSSValue(properties[i]);

2936

if (value)

2937

list.append(CSSProperty(properties[i], value.release(), false));

2938

}

Torne (Richard Coles)

2013-05-29 14:40:20 +0100

[diff] [blame]

2939

return MutableStylePropertySet::create(list.data(), list.size());

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2940

}

2941

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2942

CSSRule* CSSComputedStyleDeclaration::parentRule() const

{

return 0;

}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(const String& propertyName)

2948

{

2949

CSSPropertyID propertyID = cssPropertyID(propertyName);

2950

if (!propertyID)

2951

return 0;

2952

RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);

2953

return value ? value->cloneForCSSOM() : 0;

2954

}

2955

2956

String CSSComputedStyleDeclaration::getPropertyValue(const String &propertyName)

2957

{

2958

CSSPropertyID propertyID = cssPropertyID(propertyName);

2959

if (!propertyID)

2960

return String();

2961

return getPropertyValue(propertyID);

2962

}

2963

2964

String CSSComputedStyleDeclaration::getPropertyPriority(const String&)

2965

{

2966

// All computed styles have a priority of not "important".

return "";

}

String CSSComputedStyleDeclaration::getPropertyShorthand(const String&)

{

return "";

}

bool CSSComputedStyleDeclaration::isPropertyImplicit(const String&)

{

return false;

}

void CSSComputedStyleDeclaration::setProperty(const String&, const String&, const String&, ExceptionCode& ec)

2981

{

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

2982

ec = NoModificationAllowedError;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

2983

}

2984

2985

String CSSComputedStyleDeclaration::removeProperty(const String&, ExceptionCode& ec)

2986

{

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

2987

ec = NoModificationAllowedError;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

return String();

}

PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValueInternal(CSSPropertyID propertyID)

2992

{

2993

return getPropertyCSSValue(propertyID);

2994

}

2995

2996

String CSSComputedStyleDeclaration::getPropertyValueInternal(CSSPropertyID propertyID)

2997

{

2998

return getPropertyValue(propertyID);

2999

}

3000

3001

void CSSComputedStyleDeclaration::setPropertyInternal(CSSPropertyID, const String&, bool, ExceptionCode& ec)

3002

{

Ben Murdoch

2013-07-17 14:56:49 +0100

[diff] [blame]

3003

ec = NoModificationAllowedError;

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

3004

}

3005

Ben Murdoch

7757ec2

2013-07-23 11:17:36 +0100

[diff] [blame]

3006

const HashMap<AtomicString, String>* CSSComputedStyleDeclaration::variableMap() const

3007

{

3008

ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());

3009

Node* styledNode = this->styledNode();

3010

if (!styledNode)

3011

return 0;

3012

RefPtr<RenderStyle> style = styledNode->computedStyle(styledNode->isPseudoElement() ? NOPSEUDO : m_pseudoElementSpecifier);

3013

if (!style)

3014

return 0;

3015

return style->variables();

3016

}

3017

3018

unsigned CSSComputedStyleDeclaration::variableCount() const

3019

{

3020

ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());

3021

const HashMap<AtomicString, String>* variables = variableMap();

3022

if (!variables)

3023

return 0;

3024

return variables->size();

3025

}

3026

3027

String CSSComputedStyleDeclaration::variableValue(const AtomicString& name) const

3028

{

3029

ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());

3030

const HashMap<AtomicString, String>* variables = variableMap();

3031

if (!variables)

3032

return emptyString();

3033

HashMap<AtomicString, String>::const_iterator it = variables->find(name);

3034

if (it == variables->end())

3035

return emptyString();

return it->value;

}

void CSSComputedStyleDeclaration::setVariableValue(const AtomicString&, const String&, ExceptionCode& ec)

3040

{

3041

ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());

3042

ec = NoModificationAllowedError;

3043

}

3044

3045

bool CSSComputedStyleDeclaration::removeVariable(const AtomicString&)

3046

{

3047

ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());

return false;

}

void CSSComputedStyleDeclaration::clearVariables(ExceptionCode& ec)

3052

{

3053

ASSERT(RuntimeEnabledFeatures::cssVariablesEnabled());

3054

ec = NoModificationAllowedError;

3055

}

3056

Torne (Richard Coles)

2013-05-09 18:38:43 +0100

[diff] [blame]

3057

PassRefPtr<CSSValueList> CSSComputedStyleDeclaration::getBackgroundShorthandValue() const

3058

{

3059

static const CSSPropertyID propertiesBeforeSlashSeperator[5] = { CSSPropertyBackgroundColor, CSSPropertyBackgroundImage,

3060

CSSPropertyBackgroundRepeat, CSSPropertyBackgroundAttachment,

3061

CSSPropertyBackgroundPosition };

3062

static const CSSPropertyID propertiesAfterSlashSeperator[3] = { CSSPropertyBackgroundSize, CSSPropertyBackgroundOrigin,

3063

CSSPropertyBackgroundClip };

3064

3065

RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();

Torne (Richard Coles)

521d96e

2013-06-19 11:58:24 +0100

[diff] [blame]

3066

list->append(getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(CSSPropertyBackground, propertiesBeforeSlashSeperator, WTF_ARRAY_LENGTH(propertiesBeforeSlashSeperator))));

3067

list->append(getCSSPropertyValuesForShorthandProperties(StylePropertyShorthand(CSSPropertyBackground, propertiesAfterSlashSeperator, WTF_ARRAY_LENGTH(propertiesAfterSlashSeperator))));

Torne (Richard Coles)