drawinglayer/source/attribute/sdrattribute.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: sdrattribute.cxx,v $
   6  *
   7  *  $Revision: 1.5 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:19 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/attribute/sdrattribute.hxx>
  40 #include <drawinglayer/attribute/fillattribute.hxx>
  41 #include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
  42
  43 //////////////////////////////////////////////////////////////////////////////
  44
  45 namespace drawinglayer
  46 {
  47     namespace attribute
  48     {
  49         SdrLineAttribute::SdrLineAttribute(
  50             basegfx::B2DLineJoin eJoin, double fWidth, double fTransparence, const basegfx::BColor& rColor,
  51             const ::std::vector< double >& rDotDashArray, double fFullDotDashLen)
  52         :       meJoin(eJoin),
  53             mfWidth(fWidth),
  54             mfTransparence(fTransparence),
  55             maColor(rColor),
  56             maDotDashArray(rDotDashArray),
  57             mfFullDotDashLen(fFullDotDashLen)
  58         {
  59         }
  60
  61         SdrLineAttribute::SdrLineAttribute(const basegfx::BColor& rColor)
  62         :       meJoin(basegfx::B2DLINEJOIN_NONE),
  63             mfWidth(0.0),
  64             mfTransparence(0.0),
  65             maColor(rColor),
  66             maDotDashArray(),
  67             mfFullDotDashLen(0.0)
  68         {
  69         }
  70
  71         SdrLineAttribute::~SdrLineAttribute()
  72         {
  73         }
  74
  75         bool SdrLineAttribute::operator==(const SdrLineAttribute& rCandidate) const
  76         {
  77             return (meJoin == rCandidate.meJoin
  78                 && mfWidth == rCandidate.mfWidth
  79                 && mfTransparence == rCandidate.mfTransparence
  80                 && maColor == rCandidate.maColor
  81                 && maDotDashArray == rCandidate.maDotDashArray);
  82         }
  83     } // end of namespace attribute
  84 } // end of namespace drawinglayer
  85
  86 //////////////////////////////////////////////////////////////////////////////
  87
  88 namespace drawinglayer
  89 {
  90     namespace attribute
  91     {
  92         SdrLineStartEndAttribute::SdrLineStartEndAttribute(
  93             const basegfx::B2DPolyPolygon& rStartPolyPolygon, const basegfx::B2DPolyPolygon& rEndPolyPolygon,
  94             double fStartWidth, double fEndWidth, bool bStartActive, bool bEndActive, bool bStartCentered, bool bEndCentered)
  95         :       maStartPolyPolygon(rStartPolyPolygon),
  96             maEndPolyPolygon(rEndPolyPolygon),
  97             mfStartWidth(fStartWidth),
  98             mfEndWidth(fEndWidth),
  99             mbStartActive(bStartActive),
 100             mbEndActive(bEndActive),
 101             mbStartCentered(bStartCentered),
 102             mbEndCentered(bEndCentered)
 103         {
 104         }
 105
 106         SdrLineStartEndAttribute::~SdrLineStartEndAttribute()
 107         {
 108         }
 109
 110         bool SdrLineStartEndAttribute::operator==(const SdrLineStartEndAttribute& rCandidate) const
 111         {
 112             return (mbStartActive == rCandidate.mbStartActive
 113                 && mbEndActive == rCandidate.mbEndActive
 114                 && mbStartCentered == rCandidate.mbStartCentered
 115                 && mbEndCentered == rCandidate.mbEndCentered
 116                 && mfStartWidth == rCandidate.mfStartWidth
 117                 && mfEndWidth == rCandidate.mfEndWidth
 118                 && maStartPolyPolygon == rCandidate.maStartPolyPolygon
 119                 && maEndPolyPolygon == rCandidate.maEndPolyPolygon);
 120         }
 121     } // end of namespace attribute
 122 } // end of namespace drawinglayer
 123
 124 //////////////////////////////////////////////////////////////////////////////
 125
 126 namespace drawinglayer
 127 {
 128     namespace attribute
 129     {
 130         SdrShadowAttribute::SdrShadowAttribute(const basegfx::B2DVector& rOffset, double fTransparence, const basegfx::BColor& rColor)
 131         :       maOffset(rOffset),
 132             mfTransparence(fTransparence),
 133             maColor(rColor)
 134         {
 135         }
 136
 137         SdrShadowAttribute::~SdrShadowAttribute()
 138         {
 139         }
 140
 141         bool SdrShadowAttribute::operator==(const SdrShadowAttribute& rCandidate) const
 142         {
 143             return (mfTransparence == rCandidate.mfTransparence
 144                 && maColor == rCandidate.maColor
 145                 && maOffset == rCandidate.maOffset);
 146         }
 147     } // end of namespace attribute
 148 } // end of namespace drawinglayer
 149
 150 //////////////////////////////////////////////////////////////////////////////
 151
 152 namespace drawinglayer
 153 {
 154     namespace attribute
 155     {
 156         SdrFillAttribute::SdrFillAttribute(
 157             double fTransparence,
 158             const basegfx::BColor& rColor,
 159             FillGradientAttribute* pGradient,
 160             FillHatchAttribute* pHatch,
 161             SdrFillBitmapAttribute* pBitmap)
 162         :       mfTransparence(fTransparence),
 163             maColor(rColor),
 164             mpGradient(pGradient),
 165             mpHatch(pHatch),
 166             mpBitmap(pBitmap)
 167         {
 168         }
 169
 170         SdrFillAttribute::SdrFillAttribute(const SdrFillAttribute& rCandidate)
 171         :       mfTransparence(1.0),
 172             mpGradient(0L),
 173             mpHatch(0L),
 174             mpBitmap(0L)
 175         {
 176             if(!(*this == rCandidate))
 177             {
 178                 *this = rCandidate;
 179             }
 180         }
 181
 182         SdrFillAttribute::~SdrFillAttribute()
 183         {
 184             delete mpGradient;
 185             delete mpHatch;
 186             delete mpBitmap;
 187         }
 188
 189         SdrFillAttribute& SdrFillAttribute::operator=(const SdrFillAttribute& rCandidate)
 190         {
 191             // copy data
 192             mfTransparence = rCandidate.mfTransparence;
 193             maColor = rCandidate.maColor;
 194
 195             // handle mpGradient
 196             {
 197                 // delete local mpGradient if necessary
 198                 if(mpGradient && ((!rCandidate.mpGradient) || (!(*mpGradient == *rCandidate.mpGradient))))
 199                 {
 200                     delete mpGradient;
 201                     mpGradient = 0L;
 202                 }
 203
 204                 // copy mpGradient if necessary
 205                 if(!mpGradient && rCandidate.mpGradient)
 206                 {
 207                     mpGradient = new FillGradientAttribute(*rCandidate.mpGradient);
 208                 }
 209             }
 210
 211             // handle mpHatch
 212             {
 213                 // delete local mpHatch if necessary
 214                 if(mpHatch && ((!rCandidate.mpHatch) || (!(*mpHatch == *rCandidate.mpHatch))))
 215                 {
 216                     delete mpHatch;
 217                     mpHatch = 0L;
 218                 }
 219
 220                 // copy mpHatch if necessary
 221                 if(!mpHatch && rCandidate.mpHatch)
 222                 {
 223                     mpHatch = new FillHatchAttribute(*rCandidate.mpHatch);
 224                 }
 225             }
 226
 227             // handle mpBitmap
 228             {
 229                 // delete local mpBitmap if necessary
 230                 if(mpBitmap && ((!rCandidate.mpBitmap) || (!(*mpBitmap == *rCandidate.mpBitmap))))
 231                 {
 232                     delete mpBitmap;
 233                     mpBitmap = 0L;
 234                 }
 235
 236                 // copy mpBitmap if necessary
 237                 if(!mpBitmap && rCandidate.mpBitmap)
 238                 {
 239                     mpBitmap = new SdrFillBitmapAttribute(*rCandidate.mpBitmap);
 240                 }
 241             }
 242
 243             return *this;
 244         }
 245
 246         bool SdrFillAttribute::operator==(const SdrFillAttribute& rCandidate) const
 247         {
 248             if(mfTransparence != rCandidate.mfTransparence)
 249                 return false;
 250
 251             if(mpGradient)
 252             {
 253                 if(!rCandidate.mpGradient)
 254                     return false;
 255
 256                 if(!(*mpGradient == *rCandidate.mpGradient))
 257                     return false;
 258             }
 259             else if(mpHatch)
 260             {
 261                 if(!rCandidate.mpHatch)
 262                     return false;
 263
 264                 if(!(*mpHatch == *rCandidate.mpHatch))
 265                     return false;
 266
 267                 if(mpHatch->isFillBackground() && !(maColor == rCandidate.maColor))
 268                     return false;
 269             }
 270             else if(mpBitmap)
 271             {
 272                 if(!rCandidate.mpBitmap)
 273                     return false;
 274
 275                 if(!(*mpBitmap == *rCandidate.mpBitmap))
 276                     return false;
 277             }
 278             else
 279             {
 280                 if(!rCandidate.isColor())
 281                     return false;
 282
 283                 if(!(maColor == rCandidate.maColor))
 284                     return false;
 285             }
 286
 287             return true;
 288         }
 289     } // end of namespace attribute
 290 } // end of namespace drawinglayer
 291
 292 //////////////////////////////////////////////////////////////////////////////
 293 // eof