Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 812 insertions, 0 deletions

diff --git a/slideshow/source/engine/shapeattributelayer.cxx b/slideshow/source/engine/shapeattributelayer.cxx
new file mode 100644
index 000000000..a688f479c
--- /dev/null
+++ b/slideshow/source/engine/shapeattributelayer.cxx
@@ -0,0 +1,812 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+// must be first
+#include <tools/diagnose_ex.h>
+#include <shapeattributelayer.hxx>
+
+#include <com/sun/star/awt/FontUnderline.hpp>
+#include <com/sun/star/awt/FontWeight.hpp>
+#include <com/sun/star/animations/AnimationAdditiveMode.hpp>
+
+#include <rtl/math.hxx>
+
+
+using namespace ::com::sun::star;
+
+
+namespace slideshow::internal
+{
+        /** Update state ids
+
+            This method updates all state IDs from possible
+            children. Whenever a child's state ID changed, we
+            increment ours.
+        */
+        void ShapeAttributeLayer::updateStateIds()
+        {
+            if( !haveChild() )
+                return;
+
+            if( mnTransformationState != mpChild->getTransformationState() )
+                ++mnTransformationState;
+            if( mnClipState != mpChild->getClipState() )
+                ++mnClipState;
+            if( mnAlphaState != mpChild->getAlphaState() )
+                ++mnAlphaState;
+            if( mnPositionState != mpChild->getPositionState() )
+                ++mnPositionState;
+            if( mnContentState != mpChild->getContentState() )
+                ++mnContentState;
+            if( mnVisibilityState != mpChild->getVisibilityState() )
+                ++mnVisibilityState;
+        }
+
+        /** Calc attribute value.
+
+            This method determines the current attribute value,
+            appropriately combining it with children values (by
+            evaluating the mnAdditiveMode member).
+         */
+        template< typename T > T ShapeAttributeLayer::calcValue( const T&                   rCurrValue,
+                                                                 bool                       bThisInstanceValid,
+                                                                 bool (ShapeAttributeLayer::*pIsValid)() const,
+                                                                 T   (ShapeAttributeLayer::*pGetValue)() const ) const
+        {
+            // deviated from the (*shared_ptr).*mpFuncPtr notation
+            // here, since gcc does not seem to parse that as a member
+            // function call anymore.
+            const bool bChildInstanceValueValid( haveChild() && (mpChild.get()->*pIsValid)() );
+
+            if( bThisInstanceValid )
+            {
+                if( bChildInstanceValueValid )
+                {
+                    // merge with child value
+                    switch( mnAdditiveMode )
+                    {
+                        default:
+                            // FALTHROUGH intended
+                        case animations::AnimationAdditiveMode::NONE:
+                            // FALTHROUGH intended
+                        case animations::AnimationAdditiveMode::BASE:
+                            // FALTHROUGH intended
+                        case animations::AnimationAdditiveMode::REPLACE:
+                            // TODO(F2): reverse-engineer the semantics of these
+                            // values
+
+                            // currently, treat them the same and replace
+                            // the child value by our own
+                            return rCurrValue;
+
+                        case animations::AnimationAdditiveMode::SUM:
+                            return rCurrValue + ((*mpChild).*pGetValue)();
+
+                        case animations::AnimationAdditiveMode::MULTIPLY:
+                            return rCurrValue * ((*mpChild).*pGetValue)();
+                    }
+                }
+                else
+                {
+                    // this object is the only one defining
+                    // the value, so take it
+                    return rCurrValue;
+                }
+            }
+            else
+            {
+                return bChildInstanceValueValid ?
+                    ((*mpChild).*pGetValue)() :
+                    T();            // pass on child value, regardless
+                                    // if it's valid or not. If not, it's
+                                    // a default anyway
+            }
+        }
+
+        ShapeAttributeLayer::ShapeAttributeLayer( const ShapeAttributeLayerSharedPtr& rChildLayer ) :
+            mpChild( rChildLayer ),
+
+            maSize(),
+            maPosition(),
+            maClip(),
+
+            maFontFamily(),
+
+            mnRotationAngle(),
+            mnShearXAngle(),
+            mnShearYAngle(),
+            mnAlpha(),
+            mnCharScale(),
+            mnCharWeight(),
+
+            meFillStyle( drawing::FillStyle_NONE ),
+            meLineStyle( drawing::LineStyle_NONE ),
+            meCharPosture( awt::FontSlant_NONE ),
+            mnUnderlineMode(),
+
+            maDimColor(),
+            maFillColor(),
+            maLineColor(),
+            maCharColor(),
+
+            mnTransformationState( rChildLayer ? rChildLayer->getTransformationState() : 0 ),
+            mnClipState( rChildLayer ? rChildLayer->getClipState() : 0),
+            mnAlphaState( rChildLayer ? rChildLayer->getAlphaState() : 0),
+            mnPositionState( rChildLayer ? rChildLayer->getPositionState() : 0 ),
+            mnContentState( rChildLayer ? rChildLayer->getContentState() : 0 ),
+            mnVisibilityState( rChildLayer ? rChildLayer->getVisibilityState() : 0 ),
+
+            mnAdditiveMode( animations::AnimationAdditiveMode::BASE ),
+
+            mbVisibility( false ),
+
+            mbWidthValid( false ),
+            mbHeightValid( false ),
+            mbPosXValid( false ),
+            mbPosYValid( false ),
+            mbClipValid( false ),
+
+            mbFontFamilyValid( false ),
+
+            mbRotationAngleValid( false ),
+            mbShearXAngleValid( false ),
+            mbShearYAngleValid( false ),
+
+            mbAlphaValid( false ),
+
+            mbCharScaleValid( false ),
+
+            mbDimColorValid( false ),
+            mbFillColorValid( false ),
+            mbLineColorValid( false ),
+            mbCharColorValid( false ),
+
+            mbFillStyleValid( false ),
+            mbLineStyleValid( false ),
+            mbCharWeightValid( false ),
+            mbUnderlineModeValid( false ),
+            mbCharPostureValid( false ),
+            mbVisibilityValid( false )
+        {
+        }
+
+        bool ShapeAttributeLayer::revokeChildLayer( const ShapeAttributeLayerSharedPtr& rChildLayer )
+        {
+            ENSURE_OR_RETURN_FALSE( rChildLayer,
+                               "ShapeAttributeLayer::revokeChildLayer(): Will not remove NULL child" );
+
+            if( !haveChild() )
+                return false; // no children, nothing to revoke.
+
+            if( mpChild == rChildLayer )
+            {
+                // we have it - replace by removed child's sibling.
+                mpChild = rChildLayer->getChildLayer();
+
+                // if we're now the first one, defensively increment _all_
+                // state ids: possibly all underlying attributes have now
+                // changed to default
+                if( !haveChild() )
+                {
+                    // TODO(P1): Check whether it pays off to check more
+                    // detailed, which attributes really change
+                    ++mnTransformationState;
+                    ++mnClipState;
+                    ++mnAlphaState;
+                    ++mnPositionState;
+                    ++mnContentState;
+                    ++mnVisibilityState;
+                }
+            }
+            else
+            {
+                // we don't have it - pass on the request
+                if( !mpChild->revokeChildLayer( rChildLayer ) )
+                    return false; // nobody has it - bail out
+            }
+
+            // something might have changed - update ids.
+            updateStateIds();
+
+            return true;
+        }
+
+        const ShapeAttributeLayerSharedPtr&  ShapeAttributeLayer::getChildLayer() const
+        {
+            return mpChild;
+        }
+
+        void ShapeAttributeLayer::setAdditiveMode( sal_Int16 nMode )
+        {
+            if( mnAdditiveMode != nMode )
+            {
+                // TODO(P1): Check whether it pays off to check more
+                // detailed, which attributes really change
+
+                // defensively increment all states - possibly each of them
+                // will change with different additive mode
+                ++mnTransformationState;
+                ++mnClipState;
+                ++mnAlphaState;
+                ++mnPositionState;
+                ++mnContentState;
+                ++mnVisibilityState;
+            }
+
+            mnAdditiveMode = nMode;
+        }
+
+        bool ShapeAttributeLayer::isWidthValid() const
+        {
+            return mbWidthValid || (haveChild() && mpChild->isWidthValid());
+        }
+
+        double ShapeAttributeLayer::getWidth() const
+        {
+            return calcValue< double >(
+                maSize.getX(),
+                mbWidthValid,
+                &ShapeAttributeLayer::isWidthValid,
+                &ShapeAttributeLayer::getWidth );
+        }
+
+        void ShapeAttributeLayer::setWidth( const double& rNewWidth )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewWidth),
+                              "ShapeAttributeLayer::setWidth(): Invalid width" );
+
+            maSize.setX( rNewWidth );
+            mbWidthValid = true;
+            ++mnTransformationState;
+        }
+
+        bool ShapeAttributeLayer::isHeightValid() const
+        {
+            return mbHeightValid || ( haveChild() && mpChild->isHeightValid() );
+        }
+
+        double ShapeAttributeLayer::getHeight() const
+        {
+            return calcValue< double >(
+                maSize.getY(),
+                mbHeightValid,
+                &ShapeAttributeLayer::isHeightValid,
+                &ShapeAttributeLayer::getHeight );
+        }
+
+        void ShapeAttributeLayer::setHeight( const double& rNewHeight )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewHeight),
+                              "ShapeAttributeLayer::setHeight(): Invalid height" );
+
+            maSize.setY( rNewHeight );
+            mbHeightValid = true;
+            ++mnTransformationState;
+        }
+
+        void ShapeAttributeLayer::setSize( const ::basegfx::B2DSize& rNewSize )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewSize.getX()) &&
+                              std::isfinite(rNewSize.getY()),
+                              "ShapeAttributeLayer::setSize(): Invalid size" );
+
+            maSize = rNewSize;
+            mbWidthValid = mbHeightValid = true;
+            ++mnTransformationState;
+        }
+
+        bool ShapeAttributeLayer::isPosXValid() const
+        {
+            return mbPosXValid || ( haveChild() && mpChild->isPosXValid() );
+        }
+
+        double ShapeAttributeLayer::getPosX() const
+        {
+            return calcValue< double >(
+                maPosition.getX(),
+                mbPosXValid,
+                &ShapeAttributeLayer::isPosXValid,
+                &ShapeAttributeLayer::getPosX );
+        }
+
+        void ShapeAttributeLayer::setPosX( const double& rNewX )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewX),
+                              "ShapeAttributeLayer::setPosX(): Invalid position" );
+
+            maPosition.setX( rNewX );
+            mbPosXValid = true;
+            ++mnPositionState;
+        }
+
+        bool ShapeAttributeLayer::isPosYValid() const
+        {
+            return mbPosYValid || ( haveChild() && mpChild->isPosYValid() );
+        }
+
+        double ShapeAttributeLayer::getPosY() const
+        {
+            return calcValue< double >(
+                maPosition.getY(),
+                mbPosYValid,
+                &ShapeAttributeLayer::isPosYValid,
+                &ShapeAttributeLayer::getPosY );
+        }
+
+        void ShapeAttributeLayer::setPosY( const double& rNewY )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewY),
+                              "ShapeAttributeLayer::setPosY(): Invalid position" );
+
+            maPosition.setY( rNewY );
+            mbPosYValid = true;
+            ++mnPositionState;
+        }
+
+        void ShapeAttributeLayer::setPosition( const ::basegfx::B2DPoint& rNewPos )
+        {
+            maPosition = rNewPos;
+            mbPosXValid = mbPosYValid = true;
+            ++mnPositionState;
+        }
+
+        bool ShapeAttributeLayer::isRotationAngleValid() const
+        {
+            return mbRotationAngleValid || ( haveChild() && mpChild->isRotationAngleValid() );
+        }
+
+        double ShapeAttributeLayer::getRotationAngle() const
+        {
+            return calcValue< double >(
+                mnRotationAngle,
+                mbRotationAngleValid,
+                &ShapeAttributeLayer::isRotationAngleValid,
+                &ShapeAttributeLayer::getRotationAngle );
+        }
+
+        void ShapeAttributeLayer::setRotationAngle( const double& rNewAngle )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewAngle),
+                              "ShapeAttributeLayer::setRotationAngle(): Invalid angle" );
+
+            mnRotationAngle = rNewAngle;
+            mbRotationAngleValid = true;
+            ++mnTransformationState;
+        }
+
+        bool ShapeAttributeLayer::isShearXAngleValid() const
+        {
+            return mbShearXAngleValid || ( haveChild() && mpChild->isShearXAngleValid() );
+        }
+
+        double ShapeAttributeLayer::getShearXAngle() const
+        {
+            return calcValue( mnShearXAngle,
+                              mbShearXAngleValid,
+                              &ShapeAttributeLayer::isShearXAngleValid,
+                              &ShapeAttributeLayer::getShearXAngle );
+        }
+
+        void ShapeAttributeLayer::setShearXAngle( const double& rNewAngle )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewAngle),
+                              "ShapeAttributeLayer::setShearXAngle(): Invalid angle" );
+
+            mnShearXAngle = rNewAngle;
+            mbShearXAngleValid = true;
+            ++mnTransformationState;
+        }
+
+        bool ShapeAttributeLayer::isShearYAngleValid() const
+        {
+            return mbShearYAngleValid || ( haveChild() && mpChild->isShearYAngleValid() );
+        }
+
+        double ShapeAttributeLayer::getShearYAngle() const
+        {
+            return calcValue( mnShearYAngle,
+                              mbShearYAngleValid,
+                              &ShapeAttributeLayer::isShearYAngleValid,
+                              &ShapeAttributeLayer::getShearYAngle );
+        }
+
+        void ShapeAttributeLayer::setShearYAngle( const double& rNewAngle )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewAngle),
+                              "ShapeAttributeLayer::setShearYAngle(): Invalid angle" );
+
+            mnShearYAngle = rNewAngle;
+            mbShearYAngleValid = true;
+            ++mnTransformationState;
+        }
+
+        bool ShapeAttributeLayer::isAlphaValid() const
+        {
+            return mbAlphaValid || ( haveChild() && mpChild->isAlphaValid() );
+        }
+
+        double ShapeAttributeLayer::getAlpha() const
+        {
+            return calcValue( mnAlpha,
+                              mbAlphaValid,
+                              &ShapeAttributeLayer::isAlphaValid,
+                              &ShapeAttributeLayer::getAlpha );
+        }
+
+        void ShapeAttributeLayer::setAlpha( const double& rNewValue )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewValue),
+                              "ShapeAttributeLayer::setAlpha(): Invalid alpha" );
+
+            mnAlpha = rNewValue;
+            mbAlphaValid = true;
+            ++mnAlphaState;
+        }
+
+        bool ShapeAttributeLayer::isClipValid() const
+        {
+            return mbClipValid || ( haveChild() && mpChild->isClipValid() );
+        }
+
+        ::basegfx::B2DPolyPolygon ShapeAttributeLayer::getClip() const
+        {
+            // TODO(F1): Implement polygon algebra for additive modes
+            if( mbClipValid )
+                return maClip;
+            else if( haveChild() )
+                return mpChild->getClip();
+            else
+                return ::basegfx::B2DPolyPolygon();
+        }
+
+        void ShapeAttributeLayer::setClip( const ::basegfx::B2DPolyPolygon& rNewClip )
+        {
+            maClip = rNewClip;
+            mbClipValid = true;
+            ++mnClipState;
+        }
+
+        bool ShapeAttributeLayer::isDimColorValid() const
+        {
+            return mbDimColorValid || ( haveChild() && mpChild->isDimColorValid() );
+        }
+
+        RGBColor ShapeAttributeLayer::getDimColor() const
+        {
+            return calcValue( maDimColor,
+                              mbDimColorValid,
+                              &ShapeAttributeLayer::isDimColorValid,
+                              &ShapeAttributeLayer::getDimColor );
+        }
+
+        void ShapeAttributeLayer::setDimColor( const RGBColor& nNewColor )
+        {
+            maDimColor = nNewColor;
+            mbDimColorValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isFillColorValid() const
+        {
+            return mbFillColorValid || ( haveChild() && mpChild->isFillColorValid() );
+        }
+
+        RGBColor ShapeAttributeLayer::getFillColor() const
+        {
+            return calcValue( maFillColor,
+                              mbFillColorValid,
+                              &ShapeAttributeLayer::isFillColorValid,
+                              &ShapeAttributeLayer::getFillColor );
+        }
+
+        void ShapeAttributeLayer::setFillColor( const RGBColor& nNewColor )
+        {
+            maFillColor = nNewColor;
+            mbFillColorValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isLineColorValid() const
+        {
+            return mbLineColorValid || ( haveChild() && mpChild->isLineColorValid() );
+        }
+
+        RGBColor  ShapeAttributeLayer::getLineColor() const
+        {
+            return calcValue( maLineColor,
+                              mbLineColorValid,
+                              &ShapeAttributeLayer::isLineColorValid,
+                              &ShapeAttributeLayer::getLineColor );
+        }
+
+        void ShapeAttributeLayer::setLineColor( const RGBColor& nNewColor )
+        {
+            maLineColor = nNewColor;
+            mbLineColorValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isFillStyleValid() const
+        {
+            return mbFillStyleValid || ( haveChild() && mpChild->isFillStyleValid() );
+        }
+
+        sal_Int16 ShapeAttributeLayer::getFillStyle() const
+        {
+            // mnAdditiveMode is ignored, cannot combine strings in
+            // any sensible way
+            if( mbFillStyleValid )
+                return sal::static_int_cast<sal_Int16>(meFillStyle);
+            else if( haveChild() )
+                return sal::static_int_cast<sal_Int16>(mpChild->getFillStyle());
+            else
+                return sal::static_int_cast<sal_Int16>(drawing::FillStyle_SOLID);
+        }
+
+        void ShapeAttributeLayer::setFillStyle( const sal_Int16& rStyle )
+        {
+            // TODO(Q1): Check range here.
+            meFillStyle = static_cast<drawing::FillStyle>(rStyle);
+            mbFillStyleValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isLineStyleValid() const
+        {
+            return mbLineStyleValid || ( haveChild() && mpChild->isLineStyleValid() );
+        }
+
+        sal_Int16 ShapeAttributeLayer::getLineStyle() const
+        {
+            // mnAdditiveMode is ignored, cannot combine strings in
+            // any sensible way
+            if( mbLineStyleValid )
+                return sal::static_int_cast<sal_Int16>(meLineStyle);
+            else if( haveChild() )
+                return sal::static_int_cast<sal_Int16>(mpChild->getLineStyle());
+            else
+                return sal::static_int_cast<sal_Int16>(drawing::LineStyle_SOLID);
+        }
+
+        void ShapeAttributeLayer::setLineStyle( const sal_Int16& rStyle )
+        {
+            // TODO(Q1): Check range here.
+            meLineStyle = static_cast<drawing::LineStyle>(rStyle);
+            mbLineStyleValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isVisibilityValid() const
+        {
+            return mbVisibilityValid || ( haveChild() && mpChild->isVisibilityValid() );
+        }
+
+        bool ShapeAttributeLayer::getVisibility() const
+        {
+            // mnAdditiveMode is ignored, SMIL spec requires to not combine
+            // bools in any sensible way
+            if( mbVisibilityValid )
+                return mbVisibility;
+            else if( haveChild() )
+                return mpChild->getVisibility();
+            else
+                return true; // default is always visible
+        }
+
+        void ShapeAttributeLayer::setVisibility( const bool& bVisible )
+        {
+            mbVisibility = bVisible;
+            mbVisibilityValid = true;
+            ++mnVisibilityState;
+        }
+
+        bool ShapeAttributeLayer::isCharColorValid() const
+        {
+            return mbCharColorValid || ( haveChild() && mpChild->isCharColorValid() );
+        }
+
+        RGBColor ShapeAttributeLayer::getCharColor() const
+        {
+            return calcValue( maCharColor,
+                              mbCharColorValid,
+                              &ShapeAttributeLayer::isCharColorValid,
+                              &ShapeAttributeLayer::getCharColor );
+        }
+
+        void ShapeAttributeLayer::setCharColor( const RGBColor& nNewColor )
+        {
+            maCharColor = nNewColor;
+            mbCharColorValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isCharWeightValid() const
+        {
+            return mbCharWeightValid || ( haveChild() && mpChild->isCharWeightValid() );
+        }
+
+        double ShapeAttributeLayer::getCharWeight() const
+        {
+            // mnAdditiveMode is ignored, cannot combine strings in
+            // any sensible way
+            if( mbCharWeightValid )
+                return mnCharWeight;
+            else if( haveChild() )
+                return mpChild->getCharWeight();
+            else
+                return awt::FontWeight::NORMAL;
+        }
+
+        void ShapeAttributeLayer::setCharWeight( const double& rValue )
+        {
+            // TODO(Q1): Check range here.
+            mnCharWeight = rValue;
+            mbCharWeightValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isUnderlineModeValid() const
+        {
+            return mbUnderlineModeValid || ( haveChild() && mpChild->isUnderlineModeValid() );
+        }
+
+        sal_Int16 ShapeAttributeLayer::getUnderlineMode() const
+        {
+            // mnAdditiveMode is ignored, SMIL spec requires to not combine
+            // bools in any sensible way
+            if( mbUnderlineModeValid )
+                return mnUnderlineMode;
+            else if( haveChild() )
+                return mpChild->getUnderlineMode();
+            else
+                return awt::FontUnderline::NONE; // default is no underline
+        }
+
+        void ShapeAttributeLayer::setUnderlineMode( const sal_Int16& rUnderlineMode )
+        {
+            // TODO(Q1): Check range here.
+            mnUnderlineMode = rUnderlineMode;
+            mbUnderlineModeValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isFontFamilyValid() const
+        {
+            return mbFontFamilyValid || ( haveChild() && mpChild->isFontFamilyValid() );
+        }
+
+        OUString ShapeAttributeLayer::getFontFamily() const
+        {
+            // mnAdditiveMode is ignored, cannot combine strings in
+            // any sensible way
+            if( mbFontFamilyValid )
+                return maFontFamily;
+            else if( haveChild() )
+                return mpChild->getFontFamily();
+            else
+                return OUString();
+        }
+
+        void ShapeAttributeLayer::setFontFamily( const OUString& rName )
+        {
+            maFontFamily = rName;
+            mbFontFamilyValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isCharPostureValid() const
+        {
+            return mbCharPostureValid || ( haveChild() && mpChild->isCharPostureValid() );
+        }
+
+        sal_Int16 ShapeAttributeLayer::getCharPosture() const
+        {
+            // mnAdditiveMode is ignored, cannot combine strings in
+            // any sensible way
+            if( mbCharPostureValid )
+                return sal::static_int_cast<sal_Int16>(meCharPosture);
+            else if( haveChild() )
+                return sal::static_int_cast<sal_Int16>(mpChild->getCharPosture());
+            else
+                return sal::static_int_cast<sal_Int16>(awt::FontSlant_NONE);
+        }
+
+        void ShapeAttributeLayer::setCharPosture( const sal_Int16& rStyle )
+        {
+            // TODO(Q1): Check range here.
+            meCharPosture = static_cast<awt::FontSlant>(rStyle);
+            mbCharPostureValid = true;
+            ++mnContentState;
+        }
+
+        bool ShapeAttributeLayer::isCharScaleValid() const
+        {
+            return mbCharScaleValid || ( haveChild() && mpChild->isCharScaleValid() );
+        }
+
+        double ShapeAttributeLayer::getCharScale() const
+        {
+            return calcValue( mnCharScale,
+                              mbCharScaleValid,
+                              &ShapeAttributeLayer::isCharScaleValid,
+                              &ShapeAttributeLayer::getCharScale );
+        }
+
+        void ShapeAttributeLayer::setCharScale( const double& rNewHeight )
+        {
+            ENSURE_OR_THROW( std::isfinite(rNewHeight),
+                              "ShapeAttributeLayer::setCharScale(): Invalid height" );
+
+            mnCharScale = rNewHeight;
+            mbCharScaleValid = true;
+            ++mnContentState;
+        }
+
+        State::StateId ShapeAttributeLayer::getTransformationState() const
+        {
+            return haveChild() ?
+                ::std::max( mnTransformationState,
+                            mpChild->getTransformationState() ) :
+                mnTransformationState;
+        }
+
+        State::StateId ShapeAttributeLayer::getClipState() const
+        {
+            return haveChild() ?
+                ::std::max( mnClipState,
+                            mpChild->getClipState() ) :
+                mnClipState;
+        }
+
+        State::StateId ShapeAttributeLayer::getAlphaState() const
+        {
+            return haveChild() ?
+                ::std::max( mnAlphaState,
+                            mpChild->getAlphaState() ) :
+                mnAlphaState;
+        }
+
+        State::StateId ShapeAttributeLayer::getPositionState() const
+         {
+            return haveChild() ?
+                ::std::max( mnPositionState,
+                            mpChild->getPositionState() ) :
+                mnPositionState;
+        }
+
+        State::StateId ShapeAttributeLayer::getContentState() const
+        {
+            return haveChild() ?
+                ::std::max( mnContentState,
+                            mpChild->getContentState() ) :
+                mnContentState;
+        }
+
+        State::StateId ShapeAttributeLayer::getVisibilityState() const
+        {
+            return haveChild() ?
+                ::std::max( mnVisibilityState,
+                            mpChild->getVisibilityState() ) :
+                mnVisibilityState;
+        }
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */