drawinglayer/source/texture/texture.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: texture.cxx,v $
   6  *
   7  *  $Revision: 1.6 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:34 $
  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/texture/texture.hxx>
  40 #include <basegfx/numeric/ftools.hxx>
  41 #include <basegfx/tools/gradienttools.hxx>
  42
  43 //////////////////////////////////////////////////////////////////////////////
  44
  45 namespace drawinglayer
  46 {
  47     namespace texture
  48     {
  49         GeoTexSvx::GeoTexSvx()
  50         {
  51         }
  52
  53         GeoTexSvx::~GeoTexSvx()
  54         {
  55         }
  56
  57         bool GeoTexSvx::operator==(const GeoTexSvx& /*rGeoTexSvx*/) const
  58         {
  59             // default implementation says yes (no data -> no difference)
  60             return true;
  61         }
  62
  63         void GeoTexSvx::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& /*rMatrices*/)
  64         {
  65             // default implementation does nothing
  66         }
  67
  68         void GeoTexSvx::modifyBColor(const basegfx::B2DPoint& /*rUV*/, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
  69         {
  70             // base implementation creates random color (for testing only, may also be pure virtual)
  71             rBColor.setRed((rand() & 0x7fff) / 32767.0);
  72             rBColor.setGreen((rand() & 0x7fff) / 32767.0);
  73             rBColor.setBlue((rand() & 0x7fff) / 32767.0);
  74         }
  75
  76         void GeoTexSvx::modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const
  77         {
  78             // base implementation uses inverse of luminance of solved color (for testing only, may also be pure virtual)
  79             basegfx::BColor aBaseColor;
  80             modifyBColor(rUV, aBaseColor, rfOpacity);
  81             rfOpacity = 1.0 - aBaseColor.luminance();
  82         }
  83     } // end of namespace texture
  84 } // end of namespace drawinglayer
  85
  86 //////////////////////////////////////////////////////////////////////////////
  87
  88 namespace drawinglayer
  89 {
  90     namespace texture
  91     {
  92         void GeoTexSvxGradient::impAppendMatrix(::std::vector< basegfx::B2DHomMatrix >& rMatrices, const basegfx::B2DRange& rRange)
  93         {
  94             basegfx::B2DHomMatrix aNew;
  95             aNew.set(0, 0, rRange.getWidth());
  96             aNew.set(1, 1, rRange.getHeight());
  97             aNew.set(0, 2, rRange.getMinX());
  98             aNew.set(1, 2, rRange.getMinY());
  99             rMatrices.push_back(maGradientInfo.maTextureTransform * aNew);
 100         }
 101
 102         void GeoTexSvxGradient::impAppendColorsRadial(::std::vector< basegfx::BColor >& rColors)
 103         {
 104             if(maGradientInfo.mnSteps)
 105             {
 106                 rColors.push_back(maStart);
 107
 108                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps - 1L; a++)
 109                 {
 110                     rColors.push_back(interpolate(maStart, maEnd, (double)a / (double)maGradientInfo.mnSteps));
 111                 }
 112
 113                 rColors.push_back(maEnd);
 114             }
 115         }
 116
 117         GeoTexSvxGradient::GeoTexSvxGradient(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder)
 118         :       maTargetRange(rTargetRange),
 119             maStart(rStart),
 120             maEnd(rEnd),
 121             mfBorder(fBorder)
 122         {
 123             maGradientInfo.mnSteps = nSteps;
 124             maGradientInfo.mfAspectRatio = 1.0;
 125         }
 126
 127         GeoTexSvxGradient::~GeoTexSvxGradient()
 128         {
 129         }
 130
 131         bool GeoTexSvxGradient::operator==(const GeoTexSvx& rGeoTexSvx) const
 132         {
 133             const GeoTexSvxGradient* pCompare = dynamic_cast< const GeoTexSvxGradient* >(&rGeoTexSvx);
 134             return (pCompare
 135                 && maGradientInfo.maTextureTransform == pCompare->maGradientInfo.maTextureTransform
 136                 && maTargetRange == pCompare->maTargetRange
 137                 && maGradientInfo.mnSteps == pCompare->maGradientInfo.mnSteps
 138                 && maGradientInfo.mfAspectRatio == pCompare->maGradientInfo.mfAspectRatio
 139                 && mfBorder == pCompare->mfBorder);
 140         }
 141     } // end of namespace texture
 142 } // end of namespace drawinglayer
 143
 144 //////////////////////////////////////////////////////////////////////////////
 145
 146 namespace drawinglayer
 147 {
 148     namespace texture
 149     {
 150         GeoTexSvxGradientLinear::GeoTexSvxGradientLinear(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fAngle)
 151         :       GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder)
 152         {
 153             basegfx::tools::createLinearODFGradientInfo(maGradientInfo,
 154                                                         rTargetRange,
 155                                                         nSteps,
 156                                                         fBorder,
 157                                                         fAngle);
 158         }
 159
 160         GeoTexSvxGradientLinear::~GeoTexSvxGradientLinear()
 161         {
 162         }
 163
 164         void GeoTexSvxGradientLinear::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 165         {
 166             if(maGradientInfo.mnSteps)
 167             {
 168                 const double fTop(mfBorder);
 169                 const double fStripeWidth((1.0 - fTop) / maGradientInfo.mnSteps);
 170
 171                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 172                 {
 173                     const double fOffsetUpper(fStripeWidth * (double)a);
 174
 175                     // create matrix
 176                     const basegfx::B2DRange aRect(0.0, fTop + fOffsetUpper, 1.0, 1.0);
 177                     impAppendMatrix(rMatrices, aRect);
 178                 }
 179             }
 180         }
 181
 182         void GeoTexSvxGradientLinear::appendColors(::std::vector< basegfx::BColor >& rColors)
 183         {
 184             if(maGradientInfo.mnSteps)
 185             {
 186                 rColors.push_back(maStart);
 187
 188                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 189                 {
 190                     rColors.push_back(interpolate(maStart, maEnd, (double)a / (double)(maGradientInfo.mnSteps + 1L)));
 191                 }
 192             }
 193         }
 194
 195         void GeoTexSvxGradientLinear::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 196         {
 197             const double fScaler(basegfx::tools::getLinearGradientAlpha(rUV, maGradientInfo));
 198
 199             rBColor = (maStart * (1.0 - fScaler)) + (maEnd * fScaler);
 200         }
 201     } // end of namespace texture
 202 } // end of namespace drawinglayer
 203
 204 //////////////////////////////////////////////////////////////////////////////
 205
 206 namespace drawinglayer
 207 {
 208     namespace texture
 209     {
 210         GeoTexSvxGradientAxial::GeoTexSvxGradientAxial(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fAngle)
 211         :       GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder)
 212         {
 213             basegfx::tools::createAxialODFGradientInfo(maGradientInfo,
 214                                                        rTargetRange,
 215                                                        nSteps,
 216                                                        fBorder,
 217                                                        fAngle);
 218         }
 219
 220         GeoTexSvxGradientAxial::~GeoTexSvxGradientAxial()
 221         {
 222         }
 223
 224         void GeoTexSvxGradientAxial::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 225         {
 226             if(maGradientInfo.mnSteps)
 227             {
 228                 const double fHalfBorder(mfBorder * 0.5);
 229                 double fTop(fHalfBorder);
 230                 double fBottom(1.0 - fHalfBorder);
 231                 const double fStripeWidth((fBottom - fTop) / ((maGradientInfo.mnSteps * 2L) - 1L));
 232
 233                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 234                 {
 235                     const double fOffset(fStripeWidth * (double)a);
 236
 237                     // create matrix
 238                     const basegfx::B2DRange aRect(0.0, fTop + fOffset, 1.0, fBottom - fOffset);
 239                     impAppendMatrix(rMatrices, aRect);
 240                 }
 241             }
 242         }
 243
 244         void GeoTexSvxGradientAxial::appendColors(::std::vector< basegfx::BColor >& rColors)
 245         {
 246             if(maGradientInfo.mnSteps)
 247             {
 248                 rColors.push_back(maEnd);
 249
 250                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 251                 {
 252                     rColors.push_back(interpolate(maEnd, maStart, (double)a / (double)maGradientInfo.mnSteps));
 253                 }
 254             }
 255         }
 256
 257         void GeoTexSvxGradientAxial::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 258         {
 259             const double fScaler(basegfx::tools::getAxialGradientAlpha(rUV, maGradientInfo));
 260
 261             rBColor = (maStart * (1.0 - fScaler)) + (maEnd * fScaler);
 262         }
 263     } // end of namespace texture
 264 } // end of namespace drawinglayer
 265
 266 //////////////////////////////////////////////////////////////////////////////
 267
 268 namespace drawinglayer
 269 {
 270     namespace texture
 271     {
 272         GeoTexSvxGradientRadial::GeoTexSvxGradientRadial(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY)
 273         :       GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder)
 274         {
 275             basegfx::tools::createRadialODFGradientInfo(maGradientInfo,
 276                                                         rTargetRange,
 277                                                         basegfx::B2DVector(fOffsetX,fOffsetY),
 278                                                         nSteps,
 279                                                         fBorder);
 280         }
 281
 282         GeoTexSvxGradientRadial::~GeoTexSvxGradientRadial()
 283         {
 284         }
 285
 286         void GeoTexSvxGradientRadial::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 287         {
 288             if(maGradientInfo.mnSteps)
 289             {
 290                 const double fHalfBorder((1.0 - mfBorder) * 0.5);
 291                 double fLeft(0.5 - fHalfBorder);
 292                 double fTop(0.5 - fHalfBorder);
 293                 double fRight(0.5 + fHalfBorder);
 294                 double fBottom(0.5 + fHalfBorder);
 295                 double fIncrementX, fIncrementY;
 296
 297                 if(maGradientInfo.mfAspectRatio > 1.0)
 298                 {
 299                     fIncrementY = (fBottom - fTop) / (double)(maGradientInfo.mnSteps * 2L);
 300                     fIncrementX = fIncrementY / maGradientInfo.mfAspectRatio;
 301                 }
 302                 else
 303                 {
 304                     fIncrementX = (fRight - fLeft) / (double)(maGradientInfo.mnSteps * 2L);
 305                     fIncrementY = fIncrementX * maGradientInfo.mfAspectRatio;
 306                 }
 307
 308                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 309                 {
 310                     // next step
 311                     fLeft += fIncrementX;
 312                     fRight -= fIncrementX;
 313                     fTop += fIncrementY;
 314                     fBottom -= fIncrementY;
 315
 316                     // create matrix
 317                     const basegfx::B2DRange aRect(fLeft, fTop, fRight, fBottom);
 318                     impAppendMatrix(rMatrices, aRect);
 319                 }
 320             }
 321         }
 322
 323         void GeoTexSvxGradientRadial::appendColors(::std::vector< basegfx::BColor >& rColors)
 324         {
 325             impAppendColorsRadial(rColors);
 326         }
 327
 328         void GeoTexSvxGradientRadial::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 329         {
 330             const double fScaler(basegfx::tools::getRadialGradientAlpha(rUV, maGradientInfo));
 331
 332             rBColor = (maStart * (1.0 - fScaler)) + (maEnd * fScaler);
 333         }
 334     } // end of namespace texture
 335 } // end of namespace drawinglayer
 336
 337 //////////////////////////////////////////////////////////////////////////////
 338
 339 namespace drawinglayer
 340 {
 341     namespace texture
 342     {
 343         GeoTexSvxGradientElliptical::GeoTexSvxGradientElliptical(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY, double fAngle)
 344         :       GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder)
 345         {
 346             basegfx::tools::createEllipticalODFGradientInfo(maGradientInfo,
 347                                                             rTargetRange,
 348                                                             basegfx::B2DVector(fOffsetX,fOffsetY),
 349                                                             nSteps,
 350                                                             fBorder,
 351                                                             fAngle);
 352         }
 353
 354         GeoTexSvxGradientElliptical::~GeoTexSvxGradientElliptical()
 355         {
 356         }
 357
 358         void GeoTexSvxGradientElliptical::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 359         {
 360             if(maGradientInfo.mnSteps)
 361             {
 362                 const double fHalfBorder((1.0 - mfBorder) * 0.5);
 363                 double fLeft(0.5 - fHalfBorder);
 364                 double fTop(0.5 - fHalfBorder);
 365                 double fRight(0.5 + fHalfBorder);
 366                 double fBottom(0.5 + fHalfBorder);
 367                 double fIncrementX, fIncrementY;
 368
 369                 if(maGradientInfo.mfAspectRatio > 1.0)
 370                 {
 371                     fIncrementY = (fBottom - fTop) / (double)(maGradientInfo.mnSteps * 2L);
 372                     fIncrementX = fIncrementY / maGradientInfo.mfAspectRatio;
 373                 }
 374                 else
 375                 {
 376                     fIncrementX = (fRight - fLeft) / (double)(maGradientInfo.mnSteps * 2L);
 377                     fIncrementY = fIncrementX * maGradientInfo.mfAspectRatio;
 378                 }
 379
 380                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 381                 {
 382                     // next step
 383                     fLeft += fIncrementX;
 384                     fRight -= fIncrementX;
 385                     fTop += fIncrementY;
 386                     fBottom -= fIncrementY;
 387
 388                     // create matrix
 389                     const basegfx::B2DRange aRect(fLeft, fTop, fRight, fBottom);
 390                     impAppendMatrix(rMatrices, aRect);
 391                 }
 392             }
 393         }
 394
 395         void GeoTexSvxGradientElliptical::appendColors(::std::vector< basegfx::BColor >& rColors)
 396         {
 397             impAppendColorsRadial(rColors);
 398         }
 399
 400         void GeoTexSvxGradientElliptical::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 401         {
 402             const double fScaler(basegfx::tools::getEllipticalGradientAlpha(rUV, maGradientInfo));
 403
 404             rBColor = (maStart * (1.0 - fScaler)) + (maEnd * fScaler);
 405         }
 406     } // end of namespace texture
 407 } // end of namespace drawinglayer
 408
 409 //////////////////////////////////////////////////////////////////////////////
 410
 411 namespace drawinglayer
 412 {
 413     namespace texture
 414     {
 415         GeoTexSvxGradientSquare::GeoTexSvxGradientSquare(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY, double fAngle)
 416         :       GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder)
 417         {
 418             basegfx::tools::createSquareODFGradientInfo(maGradientInfo,
 419                                                         rTargetRange,
 420                                                         basegfx::B2DVector(fOffsetX,fOffsetY),
 421                                                         nSteps,
 422                                                         fBorder,
 423                                                         fAngle);
 424         }
 425
 426         GeoTexSvxGradientSquare::~GeoTexSvxGradientSquare()
 427         {
 428         }
 429
 430         void GeoTexSvxGradientSquare::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 431         {
 432             if(maGradientInfo.mnSteps)
 433             {
 434                 const double fHalfBorder((1.0 - mfBorder) * 0.5);
 435                 double fLeft(0.5 - fHalfBorder);
 436                 double fTop(0.5 - fHalfBorder);
 437                 double fRight(0.5 + fHalfBorder);
 438                 double fBottom(0.5 + fHalfBorder);
 439                 double fIncrementX, fIncrementY;
 440
 441                 if(maGradientInfo.mfAspectRatio > 1.0)
 442                 {
 443                     const double fWidth(fRight - fLeft);
 444                     const double fHalfAspectExpansion(((maGradientInfo.mfAspectRatio - 1.0) * 0.5) * fWidth);
 445                     fTop -= fHalfAspectExpansion;
 446                     fBottom += fHalfAspectExpansion;
 447                     fIncrementX = fWidth / (double)(maGradientInfo.mnSteps * 2L);
 448                     fIncrementY = fIncrementX * maGradientInfo.mfAspectRatio;
 449                 }
 450                 else
 451                 {
 452                     const double fHeight(fBottom - fTop);
 453                     const double fHalfAspectExpansion((((1.0 / maGradientInfo.mfAspectRatio) - 1.0) * 0.5) * fHeight);
 454                     fLeft -= fHalfAspectExpansion;
 455                     fRight += fHalfAspectExpansion;
 456                     fIncrementY = fHeight / (double)(maGradientInfo.mnSteps * 2L);
 457                     fIncrementX = fIncrementY / maGradientInfo.mfAspectRatio;
 458                 }
 459
 460                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 461                 {
 462                     // next step
 463                     fLeft += fIncrementX;
 464                     fRight -= fIncrementX;
 465                     fTop += fIncrementY;
 466                     fBottom -= fIncrementY;
 467
 468                     // create matrix
 469                     const basegfx::B2DRange aRect(fLeft, fTop, fRight, fBottom);
 470                     impAppendMatrix(rMatrices, aRect);
 471                 }
 472             }
 473         }
 474
 475         void GeoTexSvxGradientSquare::appendColors(::std::vector< basegfx::BColor >& rColors)
 476         {
 477             impAppendColorsRadial(rColors);
 478         }
 479
 480         void GeoTexSvxGradientSquare::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 481         {
 482             const double fScaler(basegfx::tools::getSquareGradientAlpha(rUV, maGradientInfo));
 483
 484             rBColor = (maStart * (1.0 - fScaler)) + (maEnd * fScaler);
 485         }
 486     } // end of namespace texture
 487 } // end of namespace drawinglayer
 488
 489 //////////////////////////////////////////////////////////////////////////////
 490
 491 namespace drawinglayer
 492 {
 493     namespace texture
 494     {
 495         GeoTexSvxGradientRect::GeoTexSvxGradientRect(const basegfx::B2DRange& rTargetRange, const basegfx::BColor& rStart, const basegfx::BColor& rEnd, sal_uInt32 nSteps, double fBorder, double fOffsetX, double fOffsetY, double fAngle)
 496         :       GeoTexSvxGradient(rTargetRange, rStart, rEnd, nSteps, fBorder)
 497         {
 498             basegfx::tools::createRectangularODFGradientInfo(maGradientInfo,
 499                                                              rTargetRange,
 500                                                              basegfx::B2DVector(fOffsetX,fOffsetY),
 501                                                              nSteps,
 502                                                              fBorder,
 503                                                              fAngle);
 504         }
 505
 506         GeoTexSvxGradientRect::~GeoTexSvxGradientRect()
 507         {
 508         }
 509
 510         void GeoTexSvxGradientRect::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 511         {
 512             if(maGradientInfo.mnSteps)
 513             {
 514                 const double fHalfBorder((1.0 - mfBorder) * 0.5);
 515                 double fLeft(0.5 - fHalfBorder);
 516                 double fTop(0.5 - fHalfBorder);
 517                 double fRight(0.5 + fHalfBorder);
 518                 double fBottom(0.5 + fHalfBorder);
 519                 double fIncrementX, fIncrementY;
 520
 521                 if(maGradientInfo.mfAspectRatio > 1.0)
 522                 {
 523                     fIncrementY = (fBottom - fTop) / (double)(maGradientInfo.mnSteps * 2L);
 524                     fIncrementX = fIncrementY / maGradientInfo.mfAspectRatio;
 525                 }
 526                 else
 527                 {
 528                     fIncrementX = (fRight - fLeft) / (double)(maGradientInfo.mnSteps * 2L);
 529                     fIncrementY = fIncrementX * maGradientInfo.mfAspectRatio;
 530                 }
 531
 532                 for(sal_uInt32 a(1L); a < maGradientInfo.mnSteps; a++)
 533                 {
 534                     // next step
 535                     fLeft += fIncrementX;
 536                     fRight -= fIncrementX;
 537                     fTop += fIncrementY;
 538                     fBottom -= fIncrementY;
 539
 540                     // create matrix
 541                     const basegfx::B2DRange aRect(fLeft, fTop, fRight, fBottom);
 542                     impAppendMatrix(rMatrices, aRect);
 543                 }
 544             }
 545         }
 546
 547         void GeoTexSvxGradientRect::appendColors(::std::vector< basegfx::BColor >& rColors)
 548         {
 549             impAppendColorsRadial(rColors);
 550         }
 551
 552         void GeoTexSvxGradientRect::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 553         {
 554             const double fScaler(basegfx::tools::getRectangularGradientAlpha(rUV, maGradientInfo));
 555
 556             rBColor = (maStart * (1.0 - fScaler)) + (maEnd * fScaler);
 557         }
 558     } // end of namespace texture
 559 } // end of namespace drawinglayer
 560
 561 //////////////////////////////////////////////////////////////////////////////
 562
 563 namespace drawinglayer
 564 {
 565     namespace texture
 566     {
 567         GeoTexSvxHatch::GeoTexSvxHatch(const basegfx::B2DRange& rTargetRange, double fDistance, double fAngle)
 568         :       mfDistance(0.1),
 569             mfAngle(fAngle),
 570             mnSteps(10L)
 571         {
 572             double fTargetSizeX(rTargetRange.getWidth());
 573             double fTargetSizeY(rTargetRange.getHeight());
 574             double fTargetOffsetX(rTargetRange.getMinX());
 575             double fTargetOffsetY(rTargetRange.getMinY());
 576
 577             // add object expansion
 578             if(0.0 != fAngle)
 579             {
 580                 const double fAbsCos(fabs(cos(fAngle)));
 581                 const double fAbsSin(fabs(sin(fAngle)));
 582                 const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin);
 583                 const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin);
 584                 fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0;
 585                 fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0;
 586                 fTargetSizeX = fNewX;
 587                 fTargetSizeY = fNewY;
 588             }
 589
 590             // add object scale before rotate
 591             maTextureTransform.scale(fTargetSizeX, fTargetSizeY);
 592
 593             // add texture rotate after scale to keep perpendicular angles
 594             if(0.0 != fAngle)
 595             {
 596                 basegfx::B2DPoint aCenter(0.5, 0.5);
 597                 aCenter *= maTextureTransform;
 598
 599                 maTextureTransform.translate(-aCenter.getX(), -aCenter.getY());
 600                 maTextureTransform.rotate(fAngle);
 601                 maTextureTransform.translate(aCenter.getX(), aCenter.getY());
 602             }
 603
 604             // add object translate
 605             maTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
 606
 607             // prepare height for texture
 608             const double fSteps((0.0 != fDistance) ? fTargetSizeY / fDistance : 10.0);
 609             mnSteps = basegfx::fround(fSteps + 0.5);
 610             mfDistance = 1.0 / fSteps;
 611
 612             // build transform from u,v to [0.0 .. 1.0]. As base, use inverse texture transform
 613             maBackTextureTransform = maTextureTransform;
 614             maBackTextureTransform.invert();
 615         }
 616
 617         GeoTexSvxHatch::~GeoTexSvxHatch()
 618         {
 619         }
 620
 621         bool GeoTexSvxHatch::operator==(const GeoTexSvx& rGeoTexSvx) const
 622         {
 623             const GeoTexSvxHatch* pCompare = dynamic_cast< const GeoTexSvxHatch* >(&rGeoTexSvx);
 624             return (pCompare
 625                 && maTextureTransform == pCompare->maTextureTransform
 626                 && mfDistance == pCompare->mfDistance
 627                 && mfAngle == pCompare->mfAngle
 628                 && mnSteps == pCompare->mnSteps);
 629         }
 630
 631         void GeoTexSvxHatch::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 632         {
 633             for(sal_uInt32 a(1L); a < mnSteps; a++)
 634             {
 635                 // create matrix
 636                 const double fOffset(mfDistance * (double)a);
 637                 basegfx::B2DHomMatrix aNew;
 638                 aNew.set(1, 2, fOffset);
 639                 rMatrices.push_back(maTextureTransform * aNew);
 640             }
 641         }
 642
 643         double GeoTexSvxHatch::getDistanceToHatch(const basegfx::B2DPoint& rUV) const
 644         {
 645             const basegfx::B2DPoint aCoor(maBackTextureTransform * rUV);
 646             return fmod(aCoor.getY(), mfDistance);
 647         }
 648     } // end of namespace texture
 649 } // end of namespace drawinglayer
 650
 651 //////////////////////////////////////////////////////////////////////////////
 652
 653 namespace drawinglayer
 654 {
 655     namespace texture
 656     {
 657         GeoTexSvxTiled::GeoTexSvxTiled(const basegfx::B2DPoint& rTopLeft, const basegfx::B2DVector& rSize)
 658         :       maTopLeft(rTopLeft),
 659             maSize(rSize)
 660         {
 661             if(basegfx::fTools::lessOrEqual(maSize.getX(), 0.0))
 662             {
 663                 maSize.setX(1.0);
 664             }
 665
 666             if(basegfx::fTools::lessOrEqual(maSize.getY(), 0.0))
 667             {
 668                 maSize.setY(1.0);
 669             }
 670         }
 671
 672         GeoTexSvxTiled::~GeoTexSvxTiled()
 673         {
 674         }
 675
 676         bool GeoTexSvxTiled::operator==(const GeoTexSvx& rGeoTexSvx) const
 677         {
 678             const GeoTexSvxTiled* pCompare = dynamic_cast< const GeoTexSvxTiled* >(&rGeoTexSvx);
 679             return (pCompare
 680                 && maTopLeft == pCompare->maTopLeft
 681                 && maSize == pCompare->maSize);
 682         }
 683
 684         void GeoTexSvxTiled::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 685         {
 686             double fStartX(maTopLeft.getX());
 687             double fStartY(maTopLeft.getY());
 688
 689             if(basegfx::fTools::more(fStartX, 0.0))
 690             {
 691                 fStartX -= (floor(fStartX / maSize.getX()) + 1.0) * maSize.getX();
 692             }
 693
 694             if(basegfx::fTools::less(fStartX + maSize.getX(), 0.0))
 695             {
 696                 fStartX += floor(-fStartX / maSize.getX()) * maSize.getX();
 697             }
 698
 699             if(basegfx::fTools::more(fStartY, 0.0))
 700             {
 701                 fStartY -= (floor(fStartY / maSize.getY()) + 1.0) * maSize.getY();
 702             }
 703
 704             if(basegfx::fTools::less(fStartY + maSize.getY(), 0.0))
 705             {
 706                 fStartY += floor(-fStartY / maSize.getY()) * maSize.getY();
 707             }
 708
 709             for(double fPosY(fStartY); basegfx::fTools::less(fPosY, 1.0); fPosY += maSize.getY())
 710             {
 711                 for(double fPosX(fStartX); basegfx::fTools::less(fPosX, 1.0); fPosX += maSize.getX())
 712                 {
 713                     basegfx::B2DHomMatrix aNew;
 714
 715                     aNew.set(0, 0, maSize.getX());
 716                     aNew.set(1, 1, maSize.getY());
 717                     aNew.set(0, 2, fPosX);
 718                     aNew.set(1, 2, fPosY);
 719
 720                     rMatrices.push_back(aNew);
 721                 }
 722             }
 723         }
 724     } // end of namespace texture
 725 } // end of namespace drawinglayer
 726
 727 //////////////////////////////////////////////////////////////////////////////
 728 // eof