svx/source/sdr/attribute/sdrallattribute.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: sdrallattribute.cxx,v $
  10  *
  11  * $Revision: 1.2 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 #include "precompiled_svx.hxx"
  33
  34 #include <svx/sdr/attribute/sdrallattribute.hxx>
  35 #include <drawinglayer/attribute/sdrattribute.hxx>
  36 #include <drawinglayer/attribute/fillattribute.hxx>
  37 #include <svx/sdr/attribute/sdrtextattribute.hxx>
  38
  39 //////////////////////////////////////////////////////////////////////////////
  40 // pointer compare define
  41 #define pointerOrContentEqual(p, q) ((p == q) || (p && q && *p == *q))
  42
  43 //////////////////////////////////////////////////////////////////////////////
  44
  45 namespace drawinglayer
  46 {
  47     namespace attribute
  48     {
  49         SdrShadowTextAttribute::SdrShadowTextAttribute(
  50             SdrShadowAttribute* pShadow,
  51             SdrTextAttribute* pTextAttribute)
  52         :       mpShadow(pShadow),
  53             mpTextAttribute(pTextAttribute)
  54         {
  55         }
  56
  57         SdrShadowTextAttribute::SdrShadowTextAttribute(
  58             const SdrShadowTextAttribute& rCandidate)
  59         :       mpShadow(0),
  60             mpTextAttribute(0)
  61         {
  62             *this = rCandidate;
  63         }
  64
  65         SdrShadowTextAttribute::~SdrShadowTextAttribute()
  66         {
  67             delete mpShadow;
  68             delete mpTextAttribute;
  69         }
  70
  71         SdrShadowTextAttribute& SdrShadowTextAttribute::operator=(const SdrShadowTextAttribute& rCandidate)
  72         {
  73             // handle mpShadow
  74             {
  75                 // delete local mpShadow if necessary
  76                 if(mpShadow)
  77                 {
  78                     delete mpShadow;
  79                     mpShadow = 0;
  80                 }
  81
  82                 // copy mpShadow if necessary
  83                 if(rCandidate.mpShadow)
  84                 {
  85                     mpShadow = new SdrShadowAttribute(*rCandidate.mpShadow);
  86                 }
  87             }
  88
  89             // handle mpTextAttribute
  90             {
  91                 // delete local mpTextAttribute if necessary
  92                 if(mpTextAttribute)
  93                 {
  94                     delete mpTextAttribute;
  95                     mpTextAttribute = 0;
  96                 }
  97
  98                 // copy mpTextAttribute if necessary
  99                 if(rCandidate.mpTextAttribute)
 100                 {
 101                     mpTextAttribute = new SdrTextAttribute(*rCandidate.mpTextAttribute);
 102                 }
 103             }
 104
 105             return *this;
 106         }
 107
 108         bool SdrShadowTextAttribute::operator==(const SdrShadowTextAttribute& rCandidate) const
 109         {
 110             // handle mpShadow
 111             if(!pointerOrContentEqual(mpShadow, rCandidate.mpShadow))
 112                 return false;
 113
 114             // handle mpTextAttribute
 115             if(!pointerOrContentEqual(mpTextAttribute, rCandidate.mpTextAttribute))
 116                 return false;
 117
 118             return true;
 119         }
 120     } // end of namespace attribute
 121 } // end of namespace drawinglayer
 122
 123 //////////////////////////////////////////////////////////////////////////////
 124
 125 namespace drawinglayer
 126 {
 127     namespace attribute
 128     {
 129         SdrFillTextAttribute::SdrFillTextAttribute(
 130             SdrFillAttribute* pFill,
 131             FillGradientAttribute* pFillFloatTransGradient,
 132             SdrTextAttribute* pTextAttribute)
 133         :       mpFill(pFill),
 134             mpFillFloatTransGradient(pFillFloatTransGradient),
 135             mpTextAttribute(pTextAttribute)
 136         {
 137         }
 138
 139         SdrFillTextAttribute::SdrFillTextAttribute(
 140             const SdrFillTextAttribute& rCandidate)
 141         :       mpFill(0),
 142             mpFillFloatTransGradient(0),
 143             mpTextAttribute(0)
 144         {
 145             *this = rCandidate;
 146         }
 147
 148         SdrFillTextAttribute::~SdrFillTextAttribute()
 149         {
 150             delete mpFill;
 151             delete mpFillFloatTransGradient;
 152             delete mpTextAttribute;
 153         }
 154
 155         SdrFillTextAttribute& SdrFillTextAttribute::operator=(const SdrFillTextAttribute& rCandidate)
 156         {
 157             // handle mpFill
 158             {
 159                 // delete local mpFill if necessary
 160                 if(mpFill)
 161                 {
 162                     delete mpFill;
 163                     mpFill = 0;
 164                 }
 165
 166                 // copy mpFill if necessary
 167                 if(rCandidate.mpFill)
 168                 {
 169                     mpFill = new attribute::SdrFillAttribute(*rCandidate.mpFill);
 170                 }
 171             }
 172
 173             // handle mpFillFloatTransGradient
 174             {
 175                 // delete local mpFillFloatTransGradient if necessary
 176                 if(mpFillFloatTransGradient)
 177                 {
 178                     delete mpFillFloatTransGradient;
 179                     mpFillFloatTransGradient = 0;
 180                 }
 181
 182                 // copy mpFillFloatTransGradient if necessary
 183                 if(rCandidate.mpFillFloatTransGradient)
 184                 {
 185                     mpFillFloatTransGradient = new FillGradientAttribute(*rCandidate.mpFillFloatTransGradient);
 186                 }
 187             }
 188
 189             // handle mpTextAttribute
 190             {
 191                 // delete local mpTextAttribute if necessary
 192                 if(mpTextAttribute)
 193                 {
 194                     delete mpTextAttribute;
 195                     mpTextAttribute = 0;
 196                 }
 197
 198                 // copy mpTextAttribute if necessary
 199                 if(rCandidate.mpTextAttribute)
 200                 {
 201                     mpTextAttribute = new SdrTextAttribute(*rCandidate.mpTextAttribute);
 202                 }
 203             }
 204
 205             return *this;
 206         }
 207
 208         bool SdrFillTextAttribute::operator==(const SdrFillTextAttribute& rCandidate) const
 209         {
 210             // handle mpFill
 211             if(!pointerOrContentEqual(mpFill, rCandidate.mpFill))
 212                 return false;
 213
 214             // handle mpFillFloatTransGradient
 215             if(!pointerOrContentEqual(mpFillFloatTransGradient, rCandidate.mpFillFloatTransGradient))
 216                 return false;
 217
 218             // handle mpTextAttribute
 219             if(!pointerOrContentEqual(mpTextAttribute, rCandidate.mpTextAttribute))
 220                 return false;
 221
 222             return true;
 223         }
 224     } // end of namespace attribute
 225 } // end of namespace drawinglayer
 226
 227 //////////////////////////////////////////////////////////////////////////////
 228
 229 namespace drawinglayer
 230 {
 231     namespace attribute
 232     {
 233         SdrLineShadowTextAttribute::SdrLineShadowTextAttribute(
 234             SdrLineAttribute* pLine,
 235             SdrLineStartEndAttribute* pLineStartEnd,
 236             SdrShadowAttribute* pShadow,
 237             SdrTextAttribute* pTextAttribute)
 238         :       SdrShadowTextAttribute(pShadow, pTextAttribute),
 239             mpLine(pLine),
 240             mpLineStartEnd(pLineStartEnd)
 241         {
 242         }
 243
 244         SdrLineShadowTextAttribute::SdrLineShadowTextAttribute(
 245             const SdrLineShadowTextAttribute& rCandidate)
 246         :       SdrShadowTextAttribute(0, 0),
 247             mpLine(0),
 248             mpLineStartEnd(0)
 249         {
 250             *this = rCandidate;
 251         }
 252
 253         SdrLineShadowTextAttribute::~SdrLineShadowTextAttribute()
 254         {
 255             delete mpLine;
 256             delete mpLineStartEnd;
 257         }
 258
 259         SdrLineShadowTextAttribute& SdrLineShadowTextAttribute::operator=(const SdrLineShadowTextAttribute& rCandidate)
 260         {
 261             // call parent
 262             SdrShadowTextAttribute::operator=(rCandidate);
 263
 264             // handle mpLine
 265             {
 266                 // delete local mpLine if necessary
 267                 if(mpLine)
 268                 {
 269                     delete mpLine;
 270                     mpLine = 0;
 271                 }
 272
 273                 // copy mpLine if necessary
 274                 if(rCandidate.mpLine)
 275                 {
 276                     mpLine = new SdrLineAttribute(*rCandidate.mpLine);
 277                 }
 278             }
 279
 280             // handle mpLineStartEnd
 281             {
 282                 // delete local mpLineStartEnd if necessary
 283                 if(mpLineStartEnd)
 284                 {
 285                     delete mpLineStartEnd;
 286                     mpLineStartEnd = 0;
 287                 }
 288
 289                 // copy mpLineStartEnd if necessary
 290                 if(rCandidate.mpLineStartEnd)
 291                 {
 292                     mpLineStartEnd = new SdrLineStartEndAttribute(*rCandidate.mpLineStartEnd);
 293                 }
 294             }
 295
 296             return *this;
 297         }
 298
 299         bool SdrLineShadowTextAttribute::operator==(const SdrLineShadowTextAttribute& rCandidate) const
 300         {
 301             // call parent
 302             if(!(SdrShadowTextAttribute::operator==(rCandidate)))
 303                 return false;
 304
 305             // handle mpLine
 306             if(!pointerOrContentEqual(mpLine, rCandidate.mpLine))
 307                 return false;
 308
 309             // handle mpLineStartEnd
 310             if(!pointerOrContentEqual(mpLineStartEnd, rCandidate.mpLineStartEnd))
 311                 return false;
 312
 313             return true;
 314         }
 315     } // end of namespace attribute
 316 } // end of namespace drawinglayer
 317
 318 //////////////////////////////////////////////////////////////////////////////
 319
 320 namespace drawinglayer
 321 {
 322     namespace attribute
 323     {
 324         SdrLineFillShadowTextAttribute::SdrLineFillShadowTextAttribute(
 325             SdrLineAttribute* pLine,
 326             attribute::SdrFillAttribute* pFill,
 327             SdrLineStartEndAttribute* pLineStartEnd,
 328             SdrShadowAttribute* pShadow,
 329             FillGradientAttribute* pFillFloatTransGradient,
 330             SdrTextAttribute* pTextAttribute)
 331         :       SdrLineShadowTextAttribute(pLine, pLineStartEnd, pShadow, pTextAttribute),
 332             mpFill(pFill),
 333             mpFillFloatTransGradient(pFillFloatTransGradient)
 334         {
 335         }
 336
 337         SdrLineFillShadowTextAttribute::SdrLineFillShadowTextAttribute(
 338             const SdrLineFillShadowTextAttribute& rCandidate)
 339         :       SdrLineShadowTextAttribute(0, 0, 0, 0),
 340             mpFill(0),
 341             mpFillFloatTransGradient(0)
 342         {
 343             *this = rCandidate;
 344         }
 345
 346         SdrLineFillShadowTextAttribute::~SdrLineFillShadowTextAttribute()
 347         {
 348             delete mpFill;
 349             delete mpFillFloatTransGradient;
 350         }
 351
 352         SdrLineFillShadowTextAttribute& SdrLineFillShadowTextAttribute::operator=(const SdrLineFillShadowTextAttribute& rCandidate)
 353         {
 354             // call parent
 355             SdrLineShadowTextAttribute::operator=(rCandidate);
 356
 357             // handle mpFill
 358             {
 359                 // delete local mpFill if necessary
 360                 if(mpFill)
 361                 {
 362                     delete mpFill;
 363                     mpFill = 0;
 364                 }
 365
 366                 // copy mpFill if necessary
 367                 if(rCandidate.mpFill)
 368                 {
 369                     mpFill = new attribute::SdrFillAttribute(*rCandidate.mpFill);
 370                 }
 371             }
 372
 373             // handle mpFillFloatTransGradient
 374             {
 375                 // delete local mpFillFloatTransGradient if necessary
 376                 if(mpFillFloatTransGradient)
 377                 {
 378                     delete mpFillFloatTransGradient;
 379                     mpFillFloatTransGradient = 0;
 380                 }
 381
 382                 // copy mpFillFloatTransGradient if necessary
 383                 if(rCandidate.mpFillFloatTransGradient)
 384                 {
 385                     mpFillFloatTransGradient = new FillGradientAttribute(*rCandidate.mpFillFloatTransGradient);
 386                 }
 387             }
 388
 389             return *this;
 390         }
 391
 392         bool SdrLineFillShadowTextAttribute::operator==(const SdrLineFillShadowTextAttribute& rCandidate) const
 393         {
 394             // call parent
 395             if(!(SdrLineShadowTextAttribute::operator==(rCandidate)))
 396                 return false;
 397
 398             // handle mpFill
 399             if(!pointerOrContentEqual(mpFill, rCandidate.mpFill))
 400                 return false;
 401
 402             // handle mpFillFloatTransGradient
 403             if(!pointerOrContentEqual(mpFillFloatTransGradient, rCandidate.mpFillFloatTransGradient))
 404                 return false;
 405
 406             return true;
 407         }
 408     } // end of namespace attribute
 409 } // end of namespace drawinglayer
 410
 411 //////////////////////////////////////////////////////////////////////////////
 412 // eof