drawinglayer/source/attribute/sdrfillgraphicattribute.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 #include <drawinglayer/attribute/sdrfillgraphicattribute.hxx>
  21 #include <drawinglayer/attribute/fillgraphicattribute.hxx>
  22 #include <rtl/instance.hxx>
  23 #include <vcl/graph.hxx>
  24
  25
  26
  27 namespace drawinglayer
  28 {
  29     namespace attribute
  30     {
  31         class ImpSdrFillGraphicAttribute
  32         {
  33         public:
  34             // data definitions
  35             Graphic                                 maFillGraphic;
  36             basegfx::B2DVector                      maGraphicLogicSize;
  37             basegfx::B2DVector                      maSize;
  38             basegfx::B2DVector                      maOffset;
  39             basegfx::B2DVector                      maOffsetPosition;
  40             basegfx::B2DVector                      maRectPoint;
  41
  42             // bitfield
  43             bool                                    mbTiling : 1;
  44             bool                                    mbStretch : 1;
  45             bool                                    mbLogSize : 1;
  46
  47             ImpSdrFillGraphicAttribute(
  48                 const Graphic& rFillGraphic,
  49                 const basegfx::B2DVector& rGraphicLogicSize,
  50                 const basegfx::B2DVector& rSize,
  51                 const basegfx::B2DVector& rOffset,
  52                 const basegfx::B2DVector& rOffsetPosition,
  53                 const basegfx::B2DVector& rRectPoint,
  54                 bool bTiling,
  55                 bool bStretch,
  56                 bool bLogSize)
  57             :   maFillGraphic(rFillGraphic),
  58                 maGraphicLogicSize(rGraphicLogicSize),
  59                 maSize(rSize),
  60                 maOffset(rOffset),
  61                 maOffsetPosition(rOffsetPosition),
  62                 maRectPoint(rRectPoint),
  63                 mbTiling(bTiling),
  64                 mbStretch(bStretch),
  65                 mbLogSize(bLogSize)
  66             {
  67             }
  68
  69             ImpSdrFillGraphicAttribute()
  70             :   maFillGraphic(Graphic()),
  71                 maGraphicLogicSize(basegfx::B2DVector()),
  72                 maSize(basegfx::B2DVector()),
  73                 maOffset(basegfx::B2DVector()),
  74                 maOffsetPosition(basegfx::B2DVector()),
  75                 maRectPoint(basegfx::B2DVector()),
  76                 mbTiling(false),
  77                 mbStretch(false),
  78                 mbLogSize(false)
  79             {
  80             }
  81
  82             // data read access
  83             const Graphic& getFillGraphic() const { return maFillGraphic; }
  84             const basegfx::B2DVector& getGraphicLogicSize() const { return maGraphicLogicSize; }
  85             const basegfx::B2DVector& getSize() const { return maSize; }
  86             const basegfx::B2DVector& getOffset() const { return maOffset; }
  87             const basegfx::B2DVector& getOffsetPosition() const { return maOffsetPosition; }
  88             const basegfx::B2DVector& getRectPoint() const { return maRectPoint; }
  89             bool getTiling() const { return mbTiling; }
  90             bool getStretch() const { return mbStretch; }
  91             bool getLogSize() const { return mbLogSize; }
  92
  93             bool operator==(const ImpSdrFillGraphicAttribute& rCandidate) const
  94             {
  95                 return (getFillGraphic() == rCandidate.getFillGraphic()
  96                     && getGraphicLogicSize() == rCandidate.getGraphicLogicSize()
  97                     && getSize() == rCandidate.getSize()
  98                     && getOffset() == rCandidate.getOffset()
  99                     && getOffsetPosition() == rCandidate.getOffsetPosition()
 100                     && getRectPoint() == rCandidate.getRectPoint()
 101                     && getTiling() == rCandidate.getTiling()
 102                     && getStretch() == rCandidate.getStretch()
 103                     && getLogSize() == rCandidate.getLogSize());
 104             }
 105         };
 106
 107         namespace
 108         {
 109             struct theGlobalDefault :
 110                 public rtl::Static< SdrFillGraphicAttribute::ImplType, theGlobalDefault > {};
 111         }
 112
 113         SdrFillGraphicAttribute::SdrFillGraphicAttribute(
 114             const Graphic& rFillGraphic,
 115             const basegfx::B2DVector& rGraphicLogicSize,
 116             const basegfx::B2DVector& rSize,
 117             const basegfx::B2DVector& rOffset,
 118             const basegfx::B2DVector& rOffsetPosition,
 119             const basegfx::B2DVector& rRectPoint,
 120             bool bTiling,
 121             bool bStretch,
 122             bool bLogSize)
 123         :   mpSdrFillGraphicAttribute(
 124                 ImpSdrFillGraphicAttribute(
 125                     rFillGraphic,
 126                     rGraphicLogicSize,
 127                     rSize,
 128                     rOffset,
 129                     rOffsetPosition,
 130                     rRectPoint,
 131                     bTiling,
 132                     bStretch,
 133                     bLogSize))
 134         {
 135         }
 136
 137         SdrFillGraphicAttribute::SdrFillGraphicAttribute()
 138         :   mpSdrFillGraphicAttribute(theGlobalDefault::get())
 139         {
 140         }
 141
 142         SdrFillGraphicAttribute::SdrFillGraphicAttribute(const SdrFillGraphicAttribute& rCandidate)
 143         :   mpSdrFillGraphicAttribute(rCandidate.mpSdrFillGraphicAttribute)
 144         {
 145         }
 146
 147         SdrFillGraphicAttribute::~SdrFillGraphicAttribute()
 148         {
 149         }
 150
 151         bool SdrFillGraphicAttribute::isDefault() const
 152         {
 153             return mpSdrFillGraphicAttribute.same_object(theGlobalDefault::get());
 154         }
 155
 156         SdrFillGraphicAttribute& SdrFillGraphicAttribute::operator=(const SdrFillGraphicAttribute& rCandidate)
 157         {
 158             mpSdrFillGraphicAttribute = rCandidate.mpSdrFillGraphicAttribute;
 159             return *this;
 160         }
 161
 162         bool SdrFillGraphicAttribute::operator==(const SdrFillGraphicAttribute& rCandidate) const
 163         {
 164             // tdf#87509 default attr is always != non-default attr, even with same values
 165             if(rCandidate.isDefault() != isDefault())
 166                 return false;
 167
 168             return rCandidate.mpSdrFillGraphicAttribute == mpSdrFillGraphicAttribute;
 169         }
 170
 171         const Graphic& SdrFillGraphicAttribute::getFillGraphic() const
 172         {
 173             return mpSdrFillGraphicAttribute->getFillGraphic();
 174         }
 175
 176         const basegfx::B2DVector& SdrFillGraphicAttribute::getGraphicLogicSize() const
 177         {
 178             return mpSdrFillGraphicAttribute->getGraphicLogicSize();
 179         }
 180
 181         const basegfx::B2DVector& SdrFillGraphicAttribute::getSize() const
 182         {
 183             return mpSdrFillGraphicAttribute->getSize();
 184         }
 185
 186         const basegfx::B2DVector& SdrFillGraphicAttribute::getOffset() const
 187         {
 188             return mpSdrFillGraphicAttribute->getOffset();
 189         }
 190
 191         const basegfx::B2DVector& SdrFillGraphicAttribute::getOffsetPosition() const
 192         {
 193             return mpSdrFillGraphicAttribute->getOffsetPosition();
 194         }
 195
 196         const basegfx::B2DVector& SdrFillGraphicAttribute::getRectPoint() const
 197         {
 198             return mpSdrFillGraphicAttribute->getRectPoint();
 199         }
 200
 201         bool SdrFillGraphicAttribute::getTiling() const
 202         {
 203             return mpSdrFillGraphicAttribute->getTiling();
 204         }
 205
 206         bool SdrFillGraphicAttribute::getStretch() const
 207         {
 208             return mpSdrFillGraphicAttribute->getStretch();
 209         }
 210
 211         FillGraphicAttribute SdrFillGraphicAttribute::createFillGraphicAttribute(const basegfx::B2DRange& rRange) const
 212         {
 213             // get logical size of bitmap (before expanding eventually)
 214             Graphic aGraphic(getFillGraphic());
 215
 216             // init values with defaults for stretched
 217             basegfx::B2DPoint aBitmapSize(1.0, 1.0);
 218             basegfx::B2DVector aBitmapTopLeft(0.0, 0.0);
 219
 220             //UUUU are changes needed? When stretched we are already done, all other values will have no influence
 221             if(getTiling() || !getStretch())
 222             {
 223                 // init values with range sizes
 224                 const double fRangeWidth(0.0 != rRange.getWidth() ? rRange.getWidth() : 1.0);
 225                 const double fRangeHeight(0.0 != rRange.getHeight() ? rRange.getHeight() : 1.0);
 226                 aBitmapSize = basegfx::B2DPoint(fRangeWidth, fRangeHeight);
 227
 228                 // size changes
 229                 if(0.0 != getSize().getX())
 230                 {
 231                     if(getSize().getX() < 0.0)
 232                     {
 233                         aBitmapSize.setX(aBitmapSize.getX() * (getSize().getX() * -0.01));
 234                     }
 235                     else
 236                     {
 237                         aBitmapSize.setX(getSize().getX());
 238                     }
 239                 }
 240                 else
 241                 {
 242                     // #i124002# use GraphicLogicSize directly, do not try to use GetPrefSize
 243                     // of the graphic, that may not be adapted to the MapMode of the target
 244                     aBitmapSize.setX(getGraphicLogicSize().getX());
 245                 }
 246
 247                 if(0.0 != getSize().getY())
 248                 {
 249                     if(getSize().getY() < 0.0)
 250                     {
 251                         aBitmapSize.setY(aBitmapSize.getY() * (getSize().getY() * -0.01));
 252                     }
 253                     else
 254                     {
 255                         aBitmapSize.setY(getSize().getY());
 256                     }
 257                 }
 258                 else
 259                 {
 260                     // #i124002# use GraphicLogicSize directly, do not try to use GetPrefSize
 261                     // of the graphic, that may not be adapted to the MapMode of the target
 262                     aBitmapSize.setY(getGraphicLogicSize().getY());
 263                 }
 264
 265                 // position changes X
 266                 if(0.0 == getRectPoint().getX())
 267                 {
 268                     aBitmapTopLeft.setX((fRangeWidth - aBitmapSize.getX()) * 0.5);
 269                 }
 270                 else if(1.0 == getRectPoint().getX())
 271                 {
 272                     aBitmapTopLeft.setX(fRangeWidth - aBitmapSize.getX());
 273                 }
 274
 275                 // offset positions are only meaningful when tiled
 276                 if(getTiling() && 0.0 != getOffsetPosition().getX())
 277                 {
 278                     aBitmapTopLeft.setX(aBitmapTopLeft.getX() + (aBitmapSize.getX() * (getOffsetPosition().getX() * 0.01)));
 279                 }
 280
 281                 // position changes Y
 282                 if(0.0 == getRectPoint().getY())
 283                 {
 284                     aBitmapTopLeft.setY((fRangeHeight - aBitmapSize.getY()) * 0.5);
 285                 }
 286                 else if(1.0 == getRectPoint().getY())
 287                 {
 288                     aBitmapTopLeft.setY(fRangeHeight - aBitmapSize.getY());
 289                 }
 290
 291                 // offset positions are only meaningful when tiled
 292                 if(getTiling() && 0.0 != getOffsetPosition().getY())
 293                 {
 294                     aBitmapTopLeft.setY(aBitmapTopLeft.getY() + (aBitmapSize.getY() * (getOffsetPosition().getY() * 0.01)));
 295                 }
 296
 297                 // apply bitmap size scaling to unit rectangle
 298                 aBitmapTopLeft.setX(aBitmapTopLeft.getX() / fRangeWidth);
 299                 aBitmapTopLeft.setY(aBitmapTopLeft.getY() / fRangeHeight);
 300                 aBitmapSize.setX(aBitmapSize.getX() / fRangeWidth);
 301                 aBitmapSize.setY(aBitmapSize.getY() / fRangeHeight);
 302             }
 303
 304             // get offset in percent
 305             const double fOffsetX(basegfx::clamp(getOffset().getX() * 0.01, 0.0, 1.0));
 306             const double fOffsetY(basegfx::clamp(getOffset().getY() * 0.01, 0.0, 1.0));
 307
 308             // create FillGraphicAttribute
 309             return FillGraphicAttribute(
 310                 aGraphic,
 311                 basegfx::B2DRange(aBitmapTopLeft, aBitmapTopLeft + aBitmapSize),
 312                 getTiling(),
 313                 fOffsetX,
 314                 fOffsetY);
 315         }
 316     } // end of namespace attribute
 317 } // end of namespace drawinglayer
 318
 319 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */