| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_slideshow.hxx" | |
| // must be first | |
| #include <canvas/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <shapeattributelayer.hxx> | |
| #include <canvas/verbosetrace.hxx> | |
| #include <com/sun/star/awt/Rectangle.hpp> | |
| #include <com/sun/star/awt/FontUnderline.hpp> | |
| #include <com/sun/star/awt/FontWeight.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/animations/AnimationAdditiveMode.hpp> | |
| #include <basegfx/numeric/ftools.hxx> | |
| #include <basegfx/polygon/b2dpolygon.hxx> | |
| #include <rtl/math.hxx> | |
| using namespace ::com::sun::star; | |
| namespace slideshow | |
| { | |
| namespace 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() ) | |
| { | |
| 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)() : false ); | |
| 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(), | |
| mnCharRotationAngle(), | |
| 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 ), | |
| mbCharRotationAngleValid( 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; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isWidthValid() : false; | |
| } | |
| double ShapeAttributeLayer::getWidth() const | |
| { | |
| return calcValue< double >( | |
| maSize.getX(), | |
| mbWidthValid, | |
| &ShapeAttributeLayer::isWidthValid, | |
| &ShapeAttributeLayer::getWidth ); | |
| } | |
| void ShapeAttributeLayer::setWidth( const double& rNewWidth ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewWidth), | |
| "ShapeAttributeLayer::setWidth(): Invalid width" ); | |
| maSize.setX( rNewWidth ); | |
| mbWidthValid = true; | |
| ++mnTransformationState; | |
| } | |
| bool ShapeAttributeLayer::isHeightValid() const | |
| { | |
| return mbHeightValid ? true : haveChild() ? mpChild->isHeightValid() : false; | |
| } | |
| double ShapeAttributeLayer::getHeight() const | |
| { | |
| return calcValue< double >( | |
| maSize.getY(), | |
| mbHeightValid, | |
| &ShapeAttributeLayer::isHeightValid, | |
| &ShapeAttributeLayer::getHeight ); | |
| } | |
| void ShapeAttributeLayer::setHeight( const double& rNewHeight ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewHeight), | |
| "ShapeAttributeLayer::setHeight(): Invalid height" ); | |
| maSize.setY( rNewHeight ); | |
| mbHeightValid = true; | |
| ++mnTransformationState; | |
| } | |
| void ShapeAttributeLayer::setSize( const ::basegfx::B2DSize& rNewSize ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewSize.getX()) && | |
| ::rtl::math::isFinite(rNewSize.getY()), | |
| "ShapeAttributeLayer::setSize(): Invalid size" ); | |
| maSize = rNewSize; | |
| mbWidthValid = mbHeightValid = true; | |
| ++mnTransformationState; | |
| } | |
| bool ShapeAttributeLayer::isPosXValid() const | |
| { | |
| return mbPosXValid ? true : haveChild() ? mpChild->isPosXValid() : false; | |
| } | |
| double ShapeAttributeLayer::getPosX() const | |
| { | |
| return calcValue< double >( | |
| maPosition.getX(), | |
| mbPosXValid, | |
| &ShapeAttributeLayer::isPosXValid, | |
| &ShapeAttributeLayer::getPosX ); | |
| } | |
| void ShapeAttributeLayer::setPosX( const double& rNewX ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewX), | |
| "ShapeAttributeLayer::setPosX(): Invalid position" ); | |
| maPosition.setX( rNewX ); | |
| mbPosXValid = true; | |
| ++mnPositionState; | |
| } | |
| bool ShapeAttributeLayer::isPosYValid() const | |
| { | |
| return mbPosYValid ? true : haveChild() ? mpChild->isPosYValid() : false; | |
| } | |
| double ShapeAttributeLayer::getPosY() const | |
| { | |
| return calcValue< double >( | |
| maPosition.getY(), | |
| mbPosYValid, | |
| &ShapeAttributeLayer::isPosYValid, | |
| &ShapeAttributeLayer::getPosY ); | |
| } | |
| void ShapeAttributeLayer::setPosY( const double& rNewY ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::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 ? true : haveChild() ? mpChild->isRotationAngleValid() : false; | |
| } | |
| double ShapeAttributeLayer::getRotationAngle() const | |
| { | |
| return calcValue< double >( | |
| mnRotationAngle, | |
| mbRotationAngleValid, | |
| &ShapeAttributeLayer::isRotationAngleValid, | |
| &ShapeAttributeLayer::getRotationAngle ); | |
| } | |
| void ShapeAttributeLayer::setRotationAngle( const double& rNewAngle ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle), | |
| "ShapeAttributeLayer::setRotationAngle(): Invalid angle" ); | |
| mnRotationAngle = rNewAngle; | |
| mbRotationAngleValid = true; | |
| ++mnTransformationState; | |
| } | |
| bool ShapeAttributeLayer::isShearXAngleValid() const | |
| { | |
| return mbShearXAngleValid ? true : haveChild() ? mpChild->isShearXAngleValid() : false; | |
| } | |
| double ShapeAttributeLayer::getShearXAngle() const | |
| { | |
| return calcValue( mnShearXAngle, | |
| mbShearXAngleValid, | |
| &ShapeAttributeLayer::isShearXAngleValid, | |
| &ShapeAttributeLayer::getShearXAngle ); | |
| } | |
| void ShapeAttributeLayer::setShearXAngle( const double& rNewAngle ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle), | |
| "ShapeAttributeLayer::setShearXAngle(): Invalid angle" ); | |
| mnShearXAngle = rNewAngle; | |
| mbShearXAngleValid = true; | |
| ++mnTransformationState; | |
| } | |
| bool ShapeAttributeLayer::isShearYAngleValid() const | |
| { | |
| return mbShearYAngleValid ? true : haveChild() ? mpChild->isShearYAngleValid() : false; | |
| } | |
| double ShapeAttributeLayer::getShearYAngle() const | |
| { | |
| return calcValue( mnShearYAngle, | |
| mbShearYAngleValid, | |
| &ShapeAttributeLayer::isShearYAngleValid, | |
| &ShapeAttributeLayer::getShearYAngle ); | |
| } | |
| void ShapeAttributeLayer::setShearYAngle( const double& rNewAngle ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle), | |
| "ShapeAttributeLayer::setShearYAngle(): Invalid angle" ); | |
| mnShearYAngle = rNewAngle; | |
| mbShearYAngleValid = true; | |
| ++mnTransformationState; | |
| } | |
| bool ShapeAttributeLayer::isAlphaValid() const | |
| { | |
| return mbAlphaValid ? true : haveChild() ? mpChild->isAlphaValid() : false; | |
| } | |
| double ShapeAttributeLayer::getAlpha() const | |
| { | |
| return calcValue( mnAlpha, | |
| mbAlphaValid, | |
| &ShapeAttributeLayer::isAlphaValid, | |
| &ShapeAttributeLayer::getAlpha ); | |
| } | |
| void ShapeAttributeLayer::setAlpha( const double& rNewValue ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewValue), | |
| "ShapeAttributeLayer::setAlpha(): Invalid alpha" ); | |
| mnAlpha = rNewValue; | |
| mbAlphaValid = true; | |
| ++mnAlphaState; | |
| } | |
| bool ShapeAttributeLayer::isClipValid() const | |
| { | |
| return mbClipValid ? true : haveChild() ? mpChild->isClipValid() : false; | |
| } | |
| ::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 ? true : haveChild() ? mpChild->isDimColorValid() : false; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isFillColorValid() : false; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isLineColorValid() : false; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isFillStyleValid() : false; | |
| } | |
| 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 = (drawing::FillStyle)rStyle; | |
| mbFillStyleValid = true; | |
| ++mnContentState; | |
| } | |
| bool ShapeAttributeLayer::isLineStyleValid() const | |
| { | |
| return mbLineStyleValid ? true : haveChild() ? mpChild->isLineStyleValid() : false; | |
| } | |
| 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 = (drawing::LineStyle)rStyle; | |
| mbLineStyleValid = true; | |
| ++mnContentState; | |
| } | |
| bool ShapeAttributeLayer::isVisibilityValid() const | |
| { | |
| return mbVisibilityValid ? true : haveChild() ? mpChild->isVisibilityValid() : false; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isCharColorValid() : false; | |
| } | |
| 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::isCharRotationAngleValid() const | |
| { | |
| return mbCharRotationAngleValid ? true : haveChild() ? mpChild->isCharRotationAngleValid() : false; | |
| } | |
| double ShapeAttributeLayer::getCharRotationAngle() const | |
| { | |
| return calcValue( mnCharRotationAngle, | |
| mbCharRotationAngleValid, | |
| &ShapeAttributeLayer::isCharRotationAngleValid, | |
| &ShapeAttributeLayer::getCharRotationAngle ); | |
| } | |
| void ShapeAttributeLayer::setCharRotationAngle( const double& rNewAngle ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle), | |
| "ShapeAttributeLayer::setCharRotationAngle(): Invalid angle" ); | |
| mnCharRotationAngle = rNewAngle; | |
| mbCharRotationAngleValid = true; | |
| ++mnContentState; | |
| } | |
| bool ShapeAttributeLayer::isCharWeightValid() const | |
| { | |
| return mbCharWeightValid ? true : haveChild() ? mpChild->isCharWeightValid() : false; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isUnderlineModeValid() : false; | |
| } | |
| 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 ? true : haveChild() ? mpChild->isFontFamilyValid() : false; | |
| } | |
| ::rtl::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 ::rtl::OUString(); | |
| } | |
| void ShapeAttributeLayer::setFontFamily( const ::rtl::OUString& rName ) | |
| { | |
| maFontFamily = rName; | |
| mbFontFamilyValid = true; | |
| ++mnContentState; | |
| } | |
| bool ShapeAttributeLayer::isCharPostureValid() const | |
| { | |
| return mbCharPostureValid ? true : haveChild() ? mpChild->isCharPostureValid() : false; | |
| } | |
| 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 = (awt::FontSlant)rStyle; | |
| mbCharPostureValid = true; | |
| ++mnContentState; | |
| } | |
| bool ShapeAttributeLayer::isCharScaleValid() const | |
| { | |
| return mbCharScaleValid ? true : haveChild() ? mpChild->isCharScaleValid() : false; | |
| } | |
| double ShapeAttributeLayer::getCharScale() const | |
| { | |
| return calcValue( mnCharScale, | |
| mbCharScaleValid, | |
| &ShapeAttributeLayer::isCharScaleValid, | |
| &ShapeAttributeLayer::getCharScale ); | |
| } | |
| void ShapeAttributeLayer::setCharScale( const double& rNewHeight ) | |
| { | |
| ENSURE_OR_THROW( ::rtl::math::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; | |
| } | |
| } | |
| } |