slideshow/source/engine/shapeattributelayer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 // must be first
  22 #include <canvas/debug.hxx>
  23 #include <tools/diagnose_ex.h>
  24 #include <shapeattributelayer.hxx>
  25
  26 #include <canvas/verbosetrace.hxx>
  27
  28
  29 #include <com/sun/star/awt/Rectangle.hpp>
  30 #include <com/sun/star/awt/FontUnderline.hpp>
  31 #include <com/sun/star/awt/FontWeight.hpp>
  32 #include <com/sun/star/beans/XPropertySet.hpp>
  33 #include <com/sun/star/animations/AnimationAdditiveMode.hpp>
  34
  35 #include <basegfx/numeric/ftools.hxx>
  36 #include <basegfx/polygon/b2dpolygon.hxx>
  37 #include <rtl/math.hxx>
  38
  39
  40 using namespace ::com::sun::star;
  41
  42
  43 namespace slideshow
  44 {
  45     namespace internal
  46     {
  47         /** Update state ids
  48
  49             This method updates all state IDs from possible
  50             children. Whenever a child's state ID changed, we
  51             increment ours.
  52         */
  53         void ShapeAttributeLayer::updateStateIds()
  54         {
  55             if( haveChild() )
  56             {
  57                 if( mnTransformationState != mpChild->getTransformationState() )
  58                     ++mnTransformationState;
  59                 if( mnClipState != mpChild->getClipState() )
  60                     ++mnClipState;
  61                 if( mnAlphaState != mpChild->getAlphaState() )
  62                     ++mnAlphaState;
  63                 if( mnPositionState != mpChild->getPositionState() )
  64                     ++mnPositionState;
  65                 if( mnContentState != mpChild->getContentState() )
  66                     ++mnContentState;
  67                 if( mnVisibilityState != mpChild->getVisibilityState() )
  68                     ++mnVisibilityState;
  69             }
  70         }
  71
  72         /** Calc attribute value.
  73
  74             This method determines the current attribute value,
  75             appropriately combining it with children values (by
  76             evaluating the mnAdditiveMode member).
  77          */
  78         template< typename T > T ShapeAttributeLayer::calcValue( const T&                   rCurrValue,
  79                                                                  bool                       bThisInstanceValid,
  80                                                                  bool (ShapeAttributeLayer::*pIsValid)() const,
  81                                                                  T   (ShapeAttributeLayer::*pGetValue)() const ) const
  82         {
  83             // deviated from the (*shared_ptr).*mpFuncPtr notation
  84             // here, since gcc does not seem to parse that as a member
  85             // function call anymore.
  86             const bool bChildInstanceValueValid( haveChild() && (mpChild.get()->*pIsValid)() );
  87
  88             if( bThisInstanceValid )
  89             {
  90                 if( bChildInstanceValueValid )
  91                 {
  92                     // merge with child value
  93                     switch( mnAdditiveMode )
  94                     {
  95                         default:
  96                             // FALTHROUGH intended
  97                         case animations::AnimationAdditiveMode::NONE:
  98                             // FALTHROUGH intended
  99                         case animations::AnimationAdditiveMode::BASE:
 100                             // FALTHROUGH intended
 101                         case animations::AnimationAdditiveMode::REPLACE:
 102                             // TODO(F2): reverse-engineer the semantics of these
 103                             // values
 104
 105                             // currently, treat them the same and replace
 106                             // the child value by our own
 107                             return rCurrValue;
 108
 109                         case animations::AnimationAdditiveMode::SUM:
 110                             return rCurrValue + ((*mpChild).*pGetValue)();
 111
 112                         case animations::AnimationAdditiveMode::MULTIPLY:
 113                             return rCurrValue * ((*mpChild).*pGetValue)();
 114                     }
 115                 }
 116                 else
 117                 {
 118                     // this object is the only one defining
 119                     // the value, so take it
 120                     return rCurrValue;
 121                 }
 122             }
 123             else
 124             {
 125                 return bChildInstanceValueValid ?
 126                     ((*mpChild).*pGetValue)() :
 127                     T();            // pass on child value, regardless
 128                                     // if it's valid or not. If not, it's
 129                                     // a default anyway
 130             }
 131         }
 132
 133         ShapeAttributeLayer::ShapeAttributeLayer( const ShapeAttributeLayerSharedPtr& rChildLayer ) :
 134             mpChild( rChildLayer ),
 135
 136             maSize(),
 137             maPosition(),
 138             maClip(),
 139
 140             maFontFamily(),
 141
 142             mnRotationAngle(),
 143             mnShearXAngle(),
 144             mnShearYAngle(),
 145             mnAlpha(),
 146             mnCharRotationAngle(),
 147             mnCharScale(),
 148             mnCharWeight(),
 149
 150             meFillStyle( drawing::FillStyle_NONE ),
 151             meLineStyle( drawing::LineStyle_NONE ),
 152             meCharPosture( awt::FontSlant_NONE ),
 153             mnUnderlineMode(),
 154
 155             maDimColor(),
 156             maFillColor(),
 157             maLineColor(),
 158             maCharColor(),
 159
 160             mnTransformationState( rChildLayer ? rChildLayer->getTransformationState() : 0 ),
 161             mnClipState( rChildLayer ? rChildLayer->getClipState() : 0),
 162             mnAlphaState( rChildLayer ? rChildLayer->getAlphaState() : 0),
 163             mnPositionState( rChildLayer ? rChildLayer->getPositionState() : 0 ),
 164             mnContentState( rChildLayer ? rChildLayer->getContentState() : 0 ),
 165             mnVisibilityState( rChildLayer ? rChildLayer->getVisibilityState() : 0 ),
 166
 167             mnAdditiveMode( animations::AnimationAdditiveMode::BASE ),
 168
 169             mbVisibility( false ),
 170
 171             mbWidthValid( false ),
 172             mbHeightValid( false ),
 173             mbPosXValid( false ),
 174             mbPosYValid( false ),
 175             mbClipValid( false ),
 176
 177             mbFontFamilyValid( false ),
 178
 179             mbRotationAngleValid( false ),
 180             mbShearXAngleValid( false ),
 181             mbShearYAngleValid( false ),
 182
 183             mbAlphaValid( false ),
 184
 185             mbCharRotationAngleValid( false ),
 186             mbCharScaleValid( false ),
 187
 188             mbDimColorValid( false ),
 189             mbFillColorValid( false ),
 190             mbLineColorValid( false ),
 191             mbCharColorValid( false ),
 192
 193             mbFillStyleValid( false ),
 194             mbLineStyleValid( false ),
 195             mbCharWeightValid( false ),
 196             mbUnderlineModeValid( false ),
 197             mbCharPostureValid( false ),
 198             mbVisibilityValid( false )
 199         {
 200         }
 201
 202         bool ShapeAttributeLayer::revokeChildLayer( const ShapeAttributeLayerSharedPtr& rChildLayer )
 203         {
 204             ENSURE_OR_RETURN_FALSE( rChildLayer,
 205                                "ShapeAttributeLayer::revokeChildLayer(): Will not remove NULL child" );
 206
 207             if( !haveChild() )
 208                 return false; // no children, nothing to revoke.
 209
 210             if( mpChild == rChildLayer )
 211             {
 212                 // we have it - replace by removed child's sibling.
 213                 mpChild = rChildLayer->getChildLayer();
 214
 215                 // if we're now the first one, defensively increment _all_
 216                 // state ids: possibly all underlying attributes have now
 217                 // changed to default
 218                 if( !haveChild() )
 219                 {
 220                     // TODO(P1): Check whether it pays off to check more
 221                     // detailed, which attributes really change
 222                     ++mnTransformationState;
 223                     ++mnClipState;
 224                     ++mnAlphaState;
 225                     ++mnPositionState;
 226                     ++mnContentState;
 227                     ++mnVisibilityState;
 228                 }
 229             }
 230             else
 231             {
 232                 // we don't have it - pass on the request
 233                 if( !mpChild->revokeChildLayer( rChildLayer ) )
 234                     return false; // nobody has it - bail out
 235             }
 236
 237             // something might have changed - update ids.
 238             updateStateIds();
 239
 240             return true;
 241         }
 242
 243         ShapeAttributeLayerSharedPtr  ShapeAttributeLayer::getChildLayer() const
 244         {
 245             return mpChild;
 246         }
 247
 248         void ShapeAttributeLayer::setAdditiveMode( sal_Int16 nMode )
 249         {
 250             if( mnAdditiveMode != nMode )
 251             {
 252                 // TODO(P1): Check whether it pays off to check more
 253                 // detailed, which attributes really change
 254
 255                 // defensively increment all states - possibly each of them
 256                 // will change with different additive mode
 257                 ++mnTransformationState;
 258                 ++mnClipState;
 259                 ++mnAlphaState;
 260                 ++mnPositionState;
 261                 ++mnContentState;
 262                 ++mnVisibilityState;
 263             }
 264
 265             mnAdditiveMode = nMode;
 266         }
 267
 268         bool ShapeAttributeLayer::isWidthValid() const
 269         {
 270             return mbWidthValid || (haveChild() && mpChild->isWidthValid());
 271         }
 272
 273         double ShapeAttributeLayer::getWidth() const
 274         {
 275             return calcValue< double >(
 276                 maSize.getX(),
 277                 mbWidthValid,
 278                 &ShapeAttributeLayer::isWidthValid,
 279                 &ShapeAttributeLayer::getWidth );
 280         }
 281
 282         void ShapeAttributeLayer::setWidth( const double& rNewWidth )
 283         {
 284             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewWidth),
 285                               "ShapeAttributeLayer::setWidth(): Invalid width" );
 286
 287             maSize.setX( rNewWidth );
 288             mbWidthValid = true;
 289             ++mnTransformationState;
 290         }
 291
 292         bool ShapeAttributeLayer::isHeightValid() const
 293         {
 294             return mbHeightValid || ( haveChild() && mpChild->isHeightValid() );
 295         }
 296
 297         double ShapeAttributeLayer::getHeight() const
 298         {
 299             return calcValue< double >(
 300                 maSize.getY(),
 301                 mbHeightValid,
 302                 &ShapeAttributeLayer::isHeightValid,
 303                 &ShapeAttributeLayer::getHeight );
 304         }
 305
 306         void ShapeAttributeLayer::setHeight( const double& rNewHeight )
 307         {
 308             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewHeight),
 309                               "ShapeAttributeLayer::setHeight(): Invalid height" );
 310
 311             maSize.setY( rNewHeight );
 312             mbHeightValid = true;
 313             ++mnTransformationState;
 314         }
 315
 316         void ShapeAttributeLayer::setSize( const ::basegfx::B2DSize& rNewSize )
 317         {
 318             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewSize.getX()) &&
 319                               ::rtl::math::isFinite(rNewSize.getY()),
 320                               "ShapeAttributeLayer::setSize(): Invalid size" );
 321
 322             maSize = rNewSize;
 323             mbWidthValid = mbHeightValid = true;
 324             ++mnTransformationState;
 325         }
 326
 327         bool ShapeAttributeLayer::isPosXValid() const
 328         {
 329             return mbPosXValid || ( haveChild() && mpChild->isPosXValid() );
 330         }
 331
 332         double ShapeAttributeLayer::getPosX() const
 333         {
 334             return calcValue< double >(
 335                 maPosition.getX(),
 336                 mbPosXValid,
 337                 &ShapeAttributeLayer::isPosXValid,
 338                 &ShapeAttributeLayer::getPosX );
 339         }
 340
 341         void ShapeAttributeLayer::setPosX( const double& rNewX )
 342         {
 343             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewX),
 344                               "ShapeAttributeLayer::setPosX(): Invalid position" );
 345
 346             maPosition.setX( rNewX );
 347             mbPosXValid = true;
 348             ++mnPositionState;
 349         }
 350
 351         bool ShapeAttributeLayer::isPosYValid() const
 352         {
 353             return mbPosYValid || ( haveChild() && mpChild->isPosYValid() );
 354         }
 355
 356         double ShapeAttributeLayer::getPosY() const
 357         {
 358             return calcValue< double >(
 359                 maPosition.getY(),
 360                 mbPosYValid,
 361                 &ShapeAttributeLayer::isPosYValid,
 362                 &ShapeAttributeLayer::getPosY );
 363         }
 364
 365         void ShapeAttributeLayer::setPosY( const double& rNewY )
 366         {
 367             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewY),
 368                               "ShapeAttributeLayer::setPosY(): Invalid position" );
 369
 370             maPosition.setY( rNewY );
 371             mbPosYValid = true;
 372             ++mnPositionState;
 373         }
 374
 375         void ShapeAttributeLayer::setPosition( const ::basegfx::B2DPoint& rNewPos )
 376         {
 377             maPosition = rNewPos;
 378             mbPosXValid = mbPosYValid = true;
 379             ++mnPositionState;
 380         }
 381
 382         bool ShapeAttributeLayer::isRotationAngleValid() const
 383         {
 384             return mbRotationAngleValid || ( haveChild() && mpChild->isRotationAngleValid() );
 385         }
 386
 387         double ShapeAttributeLayer::getRotationAngle() const
 388         {
 389             return calcValue< double >(
 390                 mnRotationAngle,
 391                 mbRotationAngleValid,
 392                 &ShapeAttributeLayer::isRotationAngleValid,
 393                 &ShapeAttributeLayer::getRotationAngle );
 394         }
 395
 396         void ShapeAttributeLayer::setRotationAngle( const double& rNewAngle )
 397         {
 398             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
 399                               "ShapeAttributeLayer::setRotationAngle(): Invalid angle" );
 400
 401             mnRotationAngle = rNewAngle;
 402             mbRotationAngleValid = true;
 403             ++mnTransformationState;
 404         }
 405
 406         bool ShapeAttributeLayer::isShearXAngleValid() const
 407         {
 408             return mbShearXAngleValid || ( haveChild() && mpChild->isShearXAngleValid() );
 409         }
 410
 411         double ShapeAttributeLayer::getShearXAngle() const
 412         {
 413             return calcValue( mnShearXAngle,
 414                               mbShearXAngleValid,
 415                               &ShapeAttributeLayer::isShearXAngleValid,
 416                               &ShapeAttributeLayer::getShearXAngle );
 417         }
 418
 419         void ShapeAttributeLayer::setShearXAngle( const double& rNewAngle )
 420         {
 421             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
 422                               "ShapeAttributeLayer::setShearXAngle(): Invalid angle" );
 423
 424             mnShearXAngle = rNewAngle;
 425             mbShearXAngleValid = true;
 426             ++mnTransformationState;
 427         }
 428
 429         bool ShapeAttributeLayer::isShearYAngleValid() const
 430         {
 431             return mbShearYAngleValid || ( haveChild() && mpChild->isShearYAngleValid() );
 432         }
 433
 434         double ShapeAttributeLayer::getShearYAngle() const
 435         {
 436             return calcValue( mnShearYAngle,
 437                               mbShearYAngleValid,
 438                               &ShapeAttributeLayer::isShearYAngleValid,
 439                               &ShapeAttributeLayer::getShearYAngle );
 440         }
 441
 442         void ShapeAttributeLayer::setShearYAngle( const double& rNewAngle )
 443         {
 444             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
 445                               "ShapeAttributeLayer::setShearYAngle(): Invalid angle" );
 446
 447             mnShearYAngle = rNewAngle;
 448             mbShearYAngleValid = true;
 449             ++mnTransformationState;
 450         }
 451
 452         bool ShapeAttributeLayer::isAlphaValid() const
 453         {
 454             return mbAlphaValid || ( haveChild() && mpChild->isAlphaValid() );
 455         }
 456
 457         double ShapeAttributeLayer::getAlpha() const
 458         {
 459             return calcValue( mnAlpha,
 460                               mbAlphaValid,
 461                               &ShapeAttributeLayer::isAlphaValid,
 462                               &ShapeAttributeLayer::getAlpha );
 463         }
 464
 465         void ShapeAttributeLayer::setAlpha( const double& rNewValue )
 466         {
 467             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewValue),
 468                               "ShapeAttributeLayer::setAlpha(): Invalid alpha" );
 469
 470             mnAlpha = rNewValue;
 471             mbAlphaValid = true;
 472             ++mnAlphaState;
 473         }
 474
 475         bool ShapeAttributeLayer::isClipValid() const
 476         {
 477             return mbClipValid || ( haveChild() && mpChild->isClipValid() );
 478         }
 479
 480         ::basegfx::B2DPolyPolygon ShapeAttributeLayer::getClip() const
 481         {
 482             // TODO(F1): Implement polygon algebra for additive modes
 483             if( mbClipValid )
 484                 return maClip;
 485             else if( haveChild() )
 486                 return mpChild->getClip();
 487             else
 488                 return ::basegfx::B2DPolyPolygon();
 489         }
 490
 491         void ShapeAttributeLayer::setClip( const ::basegfx::B2DPolyPolygon& rNewClip )
 492         {
 493             maClip = rNewClip;
 494             mbClipValid = true;
 495             ++mnClipState;
 496         }
 497
 498         bool ShapeAttributeLayer::isDimColorValid() const
 499         {
 500             return mbDimColorValid || ( haveChild() && mpChild->isDimColorValid() );
 501         }
 502
 503         RGBColor ShapeAttributeLayer::getDimColor() const
 504         {
 505             return calcValue( maDimColor,
 506                               mbDimColorValid,
 507                               &ShapeAttributeLayer::isDimColorValid,
 508                               &ShapeAttributeLayer::getDimColor );
 509         }
 510
 511         void ShapeAttributeLayer::setDimColor( const RGBColor& nNewColor )
 512         {
 513             maDimColor = nNewColor;
 514             mbDimColorValid = true;
 515             ++mnContentState;
 516         }
 517
 518         bool ShapeAttributeLayer::isFillColorValid() const
 519         {
 520             return mbFillColorValid || ( haveChild() && mpChild->isFillColorValid() );
 521         }
 522
 523         RGBColor ShapeAttributeLayer::getFillColor() const
 524         {
 525             return calcValue( maFillColor,
 526                               mbFillColorValid,
 527                               &ShapeAttributeLayer::isFillColorValid,
 528                               &ShapeAttributeLayer::getFillColor );
 529         }
 530
 531         void ShapeAttributeLayer::setFillColor( const RGBColor& nNewColor )
 532         {
 533             maFillColor = nNewColor;
 534             mbFillColorValid = true;
 535             ++mnContentState;
 536         }
 537
 538         bool ShapeAttributeLayer::isLineColorValid() const
 539         {
 540             return mbLineColorValid || ( haveChild() && mpChild->isLineColorValid() );
 541         }
 542
 543         RGBColor  ShapeAttributeLayer::getLineColor() const
 544         {
 545             return calcValue( maLineColor,
 546                               mbLineColorValid,
 547                               &ShapeAttributeLayer::isLineColorValid,
 548                               &ShapeAttributeLayer::getLineColor );
 549         }
 550
 551         void ShapeAttributeLayer::setLineColor( const RGBColor& nNewColor )
 552         {
 553             maLineColor = nNewColor;
 554             mbLineColorValid = true;
 555             ++mnContentState;
 556         }
 557
 558         bool ShapeAttributeLayer::isFillStyleValid() const
 559         {
 560             return mbFillStyleValid || ( haveChild() && mpChild->isFillStyleValid() );
 561         }
 562
 563         sal_Int16 ShapeAttributeLayer::getFillStyle() const
 564         {
 565             // mnAdditiveMode is ignored, cannot combine strings in
 566             // any sensible way
 567             if( mbFillStyleValid )
 568                 return sal::static_int_cast<sal_Int16>(meFillStyle);
 569             else if( haveChild() )
 570                 return sal::static_int_cast<sal_Int16>(mpChild->getFillStyle());
 571             else
 572                 return sal::static_int_cast<sal_Int16>(drawing::FillStyle_SOLID);
 573         }
 574
 575         void ShapeAttributeLayer::setFillStyle( const sal_Int16& rStyle )
 576         {
 577             // TODO(Q1): Check range here.
 578             meFillStyle = (drawing::FillStyle)rStyle;
 579             mbFillStyleValid = true;
 580             ++mnContentState;
 581         }
 582
 583         bool ShapeAttributeLayer::isLineStyleValid() const
 584         {
 585             return mbLineStyleValid || ( haveChild() && mpChild->isLineStyleValid() );
 586         }
 587
 588         sal_Int16 ShapeAttributeLayer::getLineStyle() const
 589         {
 590             // mnAdditiveMode is ignored, cannot combine strings in
 591             // any sensible way
 592             if( mbLineStyleValid )
 593                 return sal::static_int_cast<sal_Int16>(meLineStyle);
 594             else if( haveChild() )
 595                 return sal::static_int_cast<sal_Int16>(mpChild->getLineStyle());
 596             else
 597                 return sal::static_int_cast<sal_Int16>(drawing::LineStyle_SOLID);
 598         }
 599
 600         void ShapeAttributeLayer::setLineStyle( const sal_Int16& rStyle )
 601         {
 602             // TODO(Q1): Check range here.
 603             meLineStyle = (drawing::LineStyle)rStyle;
 604             mbLineStyleValid = true;
 605             ++mnContentState;
 606         }
 607
 608         bool ShapeAttributeLayer::isVisibilityValid() const
 609         {
 610             return mbVisibilityValid || ( haveChild() && mpChild->isVisibilityValid() );
 611         }
 612
 613         bool ShapeAttributeLayer::getVisibility() const
 614         {
 615             // mnAdditiveMode is ignored, SMIL spec requires to not combine
 616             // bools in any sensible way
 617             if( mbVisibilityValid )
 618                 return mbVisibility;
 619             else if( haveChild() )
 620                 return mpChild->getVisibility();
 621             else
 622                 return true; // default is always visible
 623         }
 624
 625         void ShapeAttributeLayer::setVisibility( const bool& bVisible )
 626         {
 627             mbVisibility = bVisible;
 628             mbVisibilityValid = true;
 629             ++mnVisibilityState;
 630         }
 631
 632         bool ShapeAttributeLayer::isCharColorValid() const
 633         {
 634             return mbCharColorValid || ( haveChild() && mpChild->isCharColorValid() );
 635         }
 636
 637         RGBColor ShapeAttributeLayer::getCharColor() const
 638         {
 639             return calcValue( maCharColor,
 640                               mbCharColorValid,
 641                               &ShapeAttributeLayer::isCharColorValid,
 642                               &ShapeAttributeLayer::getCharColor );
 643         }
 644
 645         void ShapeAttributeLayer::setCharColor( const RGBColor& nNewColor )
 646         {
 647             maCharColor = nNewColor;
 648             mbCharColorValid = true;
 649             ++mnContentState;
 650         }
 651
 652         bool ShapeAttributeLayer::isCharRotationAngleValid() const
 653         {
 654             return mbCharRotationAngleValid || ( haveChild() && mpChild->isCharRotationAngleValid() );
 655         }
 656
 657         double ShapeAttributeLayer::getCharRotationAngle() const
 658         {
 659             return calcValue( mnCharRotationAngle,
 660                               mbCharRotationAngleValid,
 661                               &ShapeAttributeLayer::isCharRotationAngleValid,
 662                               &ShapeAttributeLayer::getCharRotationAngle );
 663         }
 664
 665         void ShapeAttributeLayer::setCharRotationAngle( const double& rNewAngle )
 666         {
 667             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewAngle),
 668                               "ShapeAttributeLayer::setCharRotationAngle(): Invalid angle" );
 669
 670             mnCharRotationAngle = rNewAngle;
 671             mbCharRotationAngleValid = true;
 672             ++mnContentState;
 673         }
 674
 675         bool ShapeAttributeLayer::isCharWeightValid() const
 676         {
 677             return mbCharWeightValid || ( haveChild() && mpChild->isCharWeightValid() );
 678         }
 679
 680         double ShapeAttributeLayer::getCharWeight() const
 681         {
 682             // mnAdditiveMode is ignored, cannot combine strings in
 683             // any sensible way
 684             if( mbCharWeightValid )
 685                 return mnCharWeight;
 686             else if( haveChild() )
 687                 return mpChild->getCharWeight();
 688             else
 689                 return awt::FontWeight::NORMAL;
 690         }
 691
 692         void ShapeAttributeLayer::setCharWeight( const double& rValue )
 693         {
 694             // TODO(Q1): Check range here.
 695             mnCharWeight = rValue;
 696             mbCharWeightValid = true;
 697             ++mnContentState;
 698         }
 699
 700         bool ShapeAttributeLayer::isUnderlineModeValid() const
 701         {
 702             return mbUnderlineModeValid || ( haveChild() && mpChild->isUnderlineModeValid() );
 703         }
 704
 705         sal_Int16 ShapeAttributeLayer::getUnderlineMode() const
 706         {
 707             // mnAdditiveMode is ignored, SMIL spec requires to not combine
 708             // bools in any sensible way
 709             if( mbUnderlineModeValid )
 710                 return mnUnderlineMode;
 711             else if( haveChild() )
 712                 return mpChild->getUnderlineMode();
 713             else
 714                 return awt::FontUnderline::NONE; // default is no underline
 715         }
 716
 717         void ShapeAttributeLayer::setUnderlineMode( const sal_Int16& rUnderlineMode )
 718         {
 719             // TODO(Q1): Check range here.
 720             mnUnderlineMode = rUnderlineMode;
 721             mbUnderlineModeValid = true;
 722             ++mnContentState;
 723         }
 724
 725         bool ShapeAttributeLayer::isFontFamilyValid() const
 726         {
 727             return mbFontFamilyValid || ( haveChild() && mpChild->isFontFamilyValid() );
 728         }
 729
 730         OUString ShapeAttributeLayer::getFontFamily() const
 731         {
 732             // mnAdditiveMode is ignored, cannot combine strings in
 733             // any sensible way
 734             if( mbFontFamilyValid )
 735                 return maFontFamily;
 736             else if( haveChild() )
 737                 return mpChild->getFontFamily();
 738             else
 739                 return OUString();
 740         }
 741
 742         void ShapeAttributeLayer::setFontFamily( const OUString& rName )
 743         {
 744             maFontFamily = rName;
 745             mbFontFamilyValid = true;
 746             ++mnContentState;
 747         }
 748
 749         bool ShapeAttributeLayer::isCharPostureValid() const
 750         {
 751             return mbCharPostureValid || ( haveChild() && mpChild->isCharPostureValid() );
 752         }
 753
 754         sal_Int16 ShapeAttributeLayer::getCharPosture() const
 755         {
 756             // mnAdditiveMode is ignored, cannot combine strings in
 757             // any sensible way
 758             if( mbCharPostureValid )
 759                 return sal::static_int_cast<sal_Int16>(meCharPosture);
 760             else if( haveChild() )
 761                 return sal::static_int_cast<sal_Int16>(mpChild->getCharPosture());
 762             else
 763                 return sal::static_int_cast<sal_Int16>(awt::FontSlant_NONE);
 764         }
 765
 766         void ShapeAttributeLayer::setCharPosture( const sal_Int16& rStyle )
 767         {
 768             // TODO(Q1): Check range here.
 769             meCharPosture = (awt::FontSlant)rStyle;
 770             mbCharPostureValid = true;
 771             ++mnContentState;
 772         }
 773
 774         bool ShapeAttributeLayer::isCharScaleValid() const
 775         {
 776             return mbCharScaleValid || ( haveChild() && mpChild->isCharScaleValid() );
 777         }
 778
 779         double ShapeAttributeLayer::getCharScale() const
 780         {
 781             return calcValue( mnCharScale,
 782                               mbCharScaleValid,
 783                               &ShapeAttributeLayer::isCharScaleValid,
 784                               &ShapeAttributeLayer::getCharScale );
 785         }
 786
 787         void ShapeAttributeLayer::setCharScale( const double& rNewHeight )
 788         {
 789             ENSURE_OR_THROW( ::rtl::math::isFinite(rNewHeight),
 790                               "ShapeAttributeLayer::setCharScale(): Invalid height" );
 791
 792             mnCharScale = rNewHeight;
 793             mbCharScaleValid = true;
 794             ++mnContentState;
 795         }
 796
 797         State::StateId ShapeAttributeLayer::getTransformationState() const
 798         {
 799             return haveChild() ?
 800                 ::std::max( mnTransformationState,
 801                             mpChild->getTransformationState() ) :
 802                 mnTransformationState;
 803         }
 804
 805         State::StateId ShapeAttributeLayer::getClipState() const
 806         {
 807             return haveChild() ?
 808                 ::std::max( mnClipState,
 809                             mpChild->getClipState() ) :
 810                 mnClipState;
 811         }
 812
 813         State::StateId ShapeAttributeLayer::getAlphaState() const
 814         {
 815             return haveChild() ?
 816                 ::std::max( mnAlphaState,
 817                             mpChild->getAlphaState() ) :
 818                 mnAlphaState;
 819         }
 820
 821         State::StateId ShapeAttributeLayer::getPositionState() const
 822          {
 823             return haveChild() ?
 824                 ::std::max( mnPositionState,
 825                             mpChild->getPositionState() ) :
 826                 mnPositionState;
 827         }
 828
 829         State::StateId ShapeAttributeLayer::getContentState() const
 830         {
 831             return haveChild() ?
 832                 ::std::max( mnContentState,
 833                             mpChild->getContentState() ) :
 834                 mnContentState;
 835         }
 836
 837         State::StateId ShapeAttributeLayer::getVisibilityState() const
 838         {
 839             return haveChild() ?
 840                 ::std::max( mnVisibilityState,
 841                             mpChild->getVisibilityState() ) :
 842                 mnVisibilityState;
 843         }
 844
 845     }
 846 }
 847
 848 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */