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