svx/source/svdraw/gradtrns.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: gradtrns.cxx,v $
  10  * $Revision: 1.7.226.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #include "gradtrns.hxx"
  35 #include <svx/svdobj.hxx>
  36 #include <basegfx/range/b2drange.hxx>
  37 #include <basegfx/matrix/b2dhommatrix.hxx>
  38 #include <vcl/salbtype.hxx>             // FRound
  39
  40 //////////////////////////////////////////////////////////////////////////////
  41
  42 void GradTransformer::GradToVec(GradTransGradient& rG, GradTransVector& rV, const SdrObject* pObj)
  43 {
  44     // handle start color
  45     rV.aCol1 = rG.aGradient.GetStartColor();
  46     if(100 != rG.aGradient.GetStartIntens())
  47     {
  48         const double fFact((double)rG.aGradient.GetStartIntens() / 100.0);
  49         rV.aCol1 = Color(rV.aCol1.getBColor() * fFact);
  50     }
  51
  52     // handle end color
  53     rV.aCol2 = rG.aGradient.GetEndColor();
  54     if(100 != rG.aGradient.GetEndIntens())
  55     {
  56         const double fFact((double)rG.aGradient.GetEndIntens() / 100.0);
  57         rV.aCol2 = Color(rV.aCol2.getBColor() * fFact);
  58     }
  59
  60     // calc the basic positions
  61     const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
  62     const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
  63     const basegfx::B2DPoint aCenter(aRange.getCenter());
  64     basegfx::B2DPoint aStartPos, aEndPos;
  65
  66     switch(rG.aGradient.GetGradientStyle())
  67     {
  68         case XGRAD_LINEAR :
  69         {
  70             aStartPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMinY());
  71             aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY());
  72
  73             if(rG.aGradient.GetBorder())
  74             {
  75                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
  76                 const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
  77                 aFullVec.normalize();
  78                 aStartPos = aEndPos + (aFullVec * fLen);
  79             }
  80
  81             if(rG.aGradient.GetAngle())
  82             {
  83                 const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
  84                 basegfx::B2DHomMatrix aTransformation;
  85
  86                 aTransformation.translate(-aCenter.getX(), -aCenter.getY());
  87                 aTransformation.rotate(-fAngle);
  88                 aTransformation.translate(aCenter.getX(), aCenter.getY());
  89
  90                 aStartPos *= aTransformation;
  91                 aEndPos *= aTransformation;
  92             }
  93             break;
  94         }
  95         case XGRAD_AXIAL :
  96         {
  97             aStartPos = aCenter;
  98             aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY());
  99
 100             if(rG.aGradient.GetBorder())
 101             {
 102                 basegfx::B2DVector aFullVec(aEndPos - aStartPos);
 103                 const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
 104                 aFullVec.normalize();
 105                 aEndPos = aStartPos + (aFullVec * fLen);
 106             }
 107
 108             if(rG.aGradient.GetAngle())
 109             {
 110                 const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
 111                 basegfx::B2DHomMatrix aTransformation;
 112
 113                 aTransformation.translate(-aCenter.getX(), -aCenter.getY());
 114                 aTransformation.rotate(-fAngle);
 115                 aTransformation.translate(aCenter.getX(), aCenter.getY());
 116
 117                 aStartPos *= aTransformation;
 118                 aEndPos *= aTransformation;
 119             }
 120             break;
 121         }
 122         case XGRAD_RADIAL :
 123         case XGRAD_SQUARE :
 124         {
 125             aStartPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMaximum().getY());
 126             aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY());
 127
 128             if(rG.aGradient.GetBorder())
 129             {
 130                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
 131                 const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
 132                 aFullVec.normalize();
 133                 aStartPos = aEndPos + (aFullVec * fLen);
 134             }
 135
 136             if(rG.aGradient.GetAngle())
 137             {
 138                 const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
 139                 basegfx::B2DHomMatrix aTransformation;
 140
 141                 aTransformation.translate(-aEndPos.getX(), -aEndPos.getY());
 142                 aTransformation.rotate(-fAngle);
 143                 aTransformation.translate(aEndPos.getX(), aEndPos.getY());
 144
 145                 aStartPos *= aTransformation;
 146                 aEndPos *= aTransformation;
 147             }
 148
 149             if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset())
 150             {
 151                 basegfx::B2DPoint aOffset(
 152                     (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0,
 153                     (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0);
 154
 155                 aStartPos += aOffset;
 156                 aEndPos += aOffset;
 157             }
 158
 159             break;
 160         }
 161         case XGRAD_ELLIPTICAL :
 162         case XGRAD_RECT :
 163         {
 164             aStartPos = basegfx::B2DPoint(aRange.getMinX(), aCenter.getY());
 165             aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY());
 166
 167             if(rG.aGradient.GetBorder())
 168             {
 169                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
 170                 const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
 171                 aFullVec.normalize();
 172                 aStartPos = aEndPos + (aFullVec * fLen);
 173             }
 174
 175             if(rG.aGradient.GetAngle())
 176             {
 177                 const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
 178                 basegfx::B2DHomMatrix aTransformation;
 179
 180                 aTransformation.translate(-aEndPos.getX(), -aEndPos.getY());
 181                 aTransformation.rotate(-fAngle);
 182                 aTransformation.translate(aEndPos.getX(), aEndPos.getY());
 183
 184                 aStartPos *= aTransformation;
 185                 aEndPos *= aTransformation;
 186             }
 187
 188             if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset())
 189             {
 190                 basegfx::B2DPoint aOffset(
 191                     (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0,
 192                     (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0);
 193
 194                 aStartPos += aOffset;
 195                 aEndPos += aOffset;
 196             }
 197
 198             break;
 199         }
 200     }
 201
 202     // set values for vector positions now
 203     rV.maPositionA = aStartPos;
 204     rV.maPositionB = aEndPos;
 205 }
 206
 207 //////////////////////////////////////////////////////////////////////////////
 208
 209 void GradTransformer::VecToGrad(GradTransVector& rV, GradTransGradient& rG, GradTransGradient& rGOld, const SdrObject* pObj,
 210     sal_Bool bMoveSingle, sal_Bool bMoveFirst)
 211 {
 212     // fill old gradient to new gradient to have a base
 213     rG = rGOld;
 214
 215     // handle color changes
 216     if(rV.aCol1 != rGOld.aGradient.GetStartColor())
 217     {
 218         rG.aGradient.SetStartColor(rV.aCol1);
 219         rG.aGradient.SetStartIntens(100);
 220     }
 221     if(rV.aCol2 != rGOld.aGradient.GetEndColor())
 222     {
 223         rG.aGradient.SetEndColor(rV.aCol2);
 224         rG.aGradient.SetEndIntens(100);
 225     }
 226
 227     // calc the basic positions
 228     const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
 229     const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
 230     const basegfx::B2DPoint aCenter(aRange.getCenter());
 231     basegfx::B2DPoint aStartPos(rV.maPositionA);
 232     basegfx::B2DPoint aEndPos(rV.maPositionB);
 233
 234     switch(rG.aGradient.GetGradientStyle())
 235     {
 236         case XGRAD_LINEAR :
 237         {
 238             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 239             {
 240                 basegfx::B2DVector aFullVec(aEndPos - aStartPos);
 241
 242                 if(bMoveSingle)
 243                 {
 244                     aFullVec = aEndPos - aCenter;
 245                 }
 246
 247                 aFullVec.normalize();
 248
 249                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 250                 fNewFullAngle /= F_PI180;
 251                 fNewFullAngle *= -10.0;
 252                 fNewFullAngle += 900.0;
 253
 254                 // clip
 255                 while(fNewFullAngle < 0.0)
 256                 {
 257                     fNewFullAngle += 3600.0;
 258                 }
 259
 260                 while(fNewFullAngle >= 3600.0)
 261                 {
 262                     fNewFullAngle -= 3600.0;
 263                 }
 264
 265                 // to int and set
 266                 sal_Int32 nNewAngle = FRound(fNewFullAngle);
 267
 268                 if(nNewAngle != rGOld.aGradient.GetAngle())
 269                 {
 270                     rG.aGradient.SetAngle(nNewAngle);
 271                 }
 272             }
 273
 274             if(!bMoveSingle || (bMoveSingle && bMoveFirst))
 275             {
 276                 const basegfx::B2DVector aFullVec(aEndPos - aStartPos);
 277                 const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
 278                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 279                 const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
 280                 const double fFullLen(aFullVec.getLength());
 281                 const double fOldLen(aOldVec.getLength());
 282                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 283                 sal_Int32 nNewBorder(100L - FRound(fNewBorder));
 284
 285                 // clip
 286                 if(nNewBorder < 0L)
 287                 {
 288                     nNewBorder = 0L;
 289                 }
 290
 291                 if(nNewBorder > 100L)
 292                 {
 293                     nNewBorder = 100L;
 294                 }
 295
 296                 // set
 297                 if(nNewBorder != rG.aGradient.GetBorder())
 298                 {
 299                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 300                 }
 301             }
 302
 303             break;
 304         }
 305         case XGRAD_AXIAL :
 306         {
 307             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 308             {
 309                 basegfx::B2DVector aFullVec(aEndPos - aCenter);
 310                 const basegfx::B2DVector aOldVec(basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()) - aCenter);
 311                 const double fFullLen(aFullVec.getLength());
 312                 const double fOldLen(aOldVec.getLength());
 313                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 314                 sal_Int32 nNewBorder = 100 - FRound(fNewBorder);
 315
 316                 // clip
 317                 if(nNewBorder < 0L)
 318                 {
 319                     nNewBorder = 0L;
 320                 }
 321
 322                 if(nNewBorder > 100L)
 323                 {
 324                     nNewBorder = 100L;
 325                 }
 326
 327                 // set
 328                 if(nNewBorder != rG.aGradient.GetBorder())
 329                 {
 330                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 331                 }
 332
 333                 aFullVec.normalize();
 334                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 335                 fNewFullAngle /= F_PI180;
 336                 fNewFullAngle *= -10.0;
 337                 fNewFullAngle += 900.0;
 338
 339                 // clip
 340                 while(fNewFullAngle < 0.0)
 341                 {
 342                     fNewFullAngle += 3600.0;
 343                 }
 344
 345                 while(fNewFullAngle >= 3600.0)
 346                 {
 347                     fNewFullAngle -= 3600.0;
 348                 }
 349
 350                 // to int and set
 351                 const sal_Int32 nNewAngle(FRound(fNewFullAngle));
 352
 353                 if(nNewAngle != rGOld.aGradient.GetAngle())
 354                 {
 355                     rG.aGradient.SetAngle(nNewAngle);
 356                 }
 357             }
 358
 359             break;
 360         }
 361         case XGRAD_RADIAL :
 362         case XGRAD_SQUARE :
 363         {
 364             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 365             {
 366                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 367                 const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
 368                 sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
 369                 sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));
 370
 371                 // clip
 372                 if(nNewXOffset < 0L)
 373                 {
 374                     nNewXOffset = 0L;
 375                 }
 376
 377                 if(nNewXOffset > 100L)
 378                 {
 379                     nNewXOffset = 100L;
 380                 }
 381
 382                 if(nNewYOffset < 0L)
 383                 {
 384                     nNewYOffset = 0L;
 385                 }
 386
 387                 if(nNewYOffset > 100L)
 388                 {
 389                     nNewYOffset = 100L;
 390                 }
 391
 392                 rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
 393                 rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);
 394
 395                 aStartPos -= aOffset;
 396                 aEndPos -= aOffset;
 397             }
 398
 399             if(!bMoveSingle || (bMoveSingle && bMoveFirst))
 400             {
 401                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
 402                 const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
 403                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 404                 const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
 405                 const double fFullLen(aFullVec.getLength());
 406                 const double fOldLen(aOldVec.getLength());
 407                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 408                 sal_Int32 nNewBorder(100L - FRound(fNewBorder));
 409
 410                 // clip
 411                 if(nNewBorder < 0L)
 412                 {
 413                     nNewBorder = 0L;
 414                 }
 415
 416                 if(nNewBorder > 100L)
 417                 {
 418                     nNewBorder = 100L;
 419                 }
 420
 421                 // set
 422                 if(nNewBorder != rG.aGradient.GetBorder())
 423                 {
 424                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 425                 }
 426
 427                 // angle is not definitely necessary for these modes, but it makes
 428                 // controlling more fun for the user
 429                 aFullVec.normalize();
 430                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 431                 fNewFullAngle /= F_PI180;
 432                 fNewFullAngle *= -10.0;
 433                 fNewFullAngle += 900.0;
 434
 435                 // clip
 436                 while(fNewFullAngle < 0.0)
 437                 {
 438                     fNewFullAngle += 3600.0;
 439                 }
 440
 441                 while(fNewFullAngle >= 3600.0)
 442                 {
 443                     fNewFullAngle -= 3600.0;
 444                 }
 445
 446                 // to int and set
 447                 const sal_Int32 nNewAngle(FRound(fNewFullAngle));
 448
 449                 if(nNewAngle != rGOld.aGradient.GetAngle())
 450                 {
 451                     rG.aGradient.SetAngle(nNewAngle);
 452                 }
 453             }
 454
 455             break;
 456         }
 457         case XGRAD_ELLIPTICAL :
 458         case XGRAD_RECT :
 459         {
 460             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 461             {
 462                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 463                 const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
 464                 sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
 465                 sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));
 466
 467                 // clip
 468                 if(nNewXOffset < 0L)
 469                 {
 470                     nNewXOffset = 0L;
 471                 }
 472
 473                 if(nNewXOffset > 100L)
 474                 {
 475                     nNewXOffset = 100L;
 476                 }
 477
 478                 if(nNewYOffset < 0L)
 479                 {
 480                     nNewYOffset = 0L;
 481                 }
 482
 483                 if(nNewYOffset > 100L)
 484                 {
 485                     nNewYOffset = 100L;
 486                 }
 487
 488                 rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
 489                 rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);
 490
 491                 aStartPos -= aOffset;
 492                 aEndPos -= aOffset;
 493             }
 494
 495             if(!bMoveSingle || (bMoveSingle && bMoveFirst))
 496             {
 497                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
 498                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 499                 const basegfx::B2DPoint aCenterLeft(aRange.getMinX(), aRange.getHeight());
 500                 const basegfx::B2DVector aOldVec(aCenterLeft - aTopLeft);
 501                 const double fFullLen(aFullVec.getLength());
 502                 const double fOldLen(aOldVec.getLength());
 503                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 504                 sal_Int32 nNewBorder(100L - FRound(fNewBorder));
 505
 506                 // clip
 507                 if(nNewBorder < 0L)
 508                 {
 509                     nNewBorder = 0L;
 510                 }
 511
 512                 if(nNewBorder > 100L)
 513                 {
 514                     nNewBorder = 100L;
 515                 }
 516
 517                 // set
 518                 if(nNewBorder != rG.aGradient.GetBorder())
 519                 {
 520                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 521                 }
 522
 523                 // angle is not definitely necessary for these modes, but it makes
 524                 // controlling more fun for the user
 525                 aFullVec.normalize();
 526                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 527                 fNewFullAngle /= F_PI180;
 528                 fNewFullAngle *= -10.0;
 529                 fNewFullAngle += 900.0;
 530
 531                 // clip
 532                 while(fNewFullAngle < 0.0)
 533                 {
 534                     fNewFullAngle += 3600.0;
 535                 }
 536
 537                 while(fNewFullAngle >= 3600.0)
 538                 {
 539                     fNewFullAngle -= 3600.0;
 540                 }
 541
 542                 // to int and set
 543                 const sal_Int32 nNewAngle(FRound(fNewFullAngle));
 544
 545                 if(nNewAngle != rGOld.aGradient.GetAngle())
 546                 {
 547                     rG.aGradient.SetAngle(nNewAngle);
 548                 }
 549             }
 550
 551             break;
 552         }
 553     }
 554 }
 555
 556 // eof