diff options
Diffstat (limited to 'slideshow/source/engine/shapeattributelayer.cxx')
| -rw-r--r-- | slideshow/source/engine/shapeattributelayer.cxx | 812 |
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: */ |