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
  28
  29
  30 void GradTransformer::GradToVec(GradTransGradient& 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 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::tools::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::tools::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::tools::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::tools::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
 183 void GradTransformer::VecToGrad(GradTransVector& rV, GradTransGradient& rG, GradTransGradient& rGOld, const SdrObject* pObj,
 184     bool bMoveSingle, bool bMoveFirst)
 185 {
 186     // fill old gradient to new gradient to have a base
 187     rG = rGOld;
 188
 189     // handle color changes
 190     if(rV.aCol1 != rGOld.aGradient.GetStartColor())
 191     {
 192         rG.aGradient.SetStartColor(rV.aCol1);
 193         rG.aGradient.SetStartIntens(100);
 194     }
 195     if(rV.aCol2 != rGOld.aGradient.GetEndColor())
 196     {
 197         rG.aGradient.SetEndColor(rV.aCol2);
 198         rG.aGradient.SetEndIntens(100);
 199     }
 200
 201     // calc the basic positions
 202     const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
 203     const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
 204     const basegfx::B2DPoint aCenter(aRange.getCenter());
 205     basegfx::B2DPoint aStartPos(rV.maPositionA);
 206     basegfx::B2DPoint aEndPos(rV.maPositionB);
 207
 208     switch(rG.aGradient.GetGradientStyle())
 209     {
 210         case css::awt::GradientStyle_LINEAR :
 211         {
 212             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 213             {
 214                 basegfx::B2DVector aFullVec(aEndPos - aStartPos);
 215
 216                 if(bMoveSingle)
 217                 {
 218                     aFullVec = aEndPos - aCenter;
 219                 }
 220
 221                 aFullVec.normalize();
 222
 223                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 224                 fNewFullAngle /= F_PI180;
 225                 fNewFullAngle *= -10.0;
 226                 fNewFullAngle += 900.0;
 227
 228                 // clip
 229                 while(fNewFullAngle < 0.0)
 230                 {
 231                     fNewFullAngle += 3600.0;
 232                 }
 233
 234                 while(fNewFullAngle >= 3600.0)
 235                 {
 236                     fNewFullAngle -= 3600.0;
 237                 }
 238
 239                 // to int and set
 240                 sal_Int32 nNewAngle = FRound(fNewFullAngle);
 241
 242                 if(nNewAngle != rGOld.aGradient.GetAngle())
 243                 {
 244                     rG.aGradient.SetAngle(nNewAngle);
 245                 }
 246             }
 247
 248             if(!bMoveSingle || (bMoveSingle && bMoveFirst))
 249             {
 250                 const basegfx::B2DVector aFullVec(aEndPos - aStartPos);
 251                 const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
 252                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 253                 const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
 254                 const double fFullLen(aFullVec.getLength());
 255                 const double fOldLen(aOldVec.getLength());
 256                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 257                 sal_Int32 nNewBorder(100L - FRound(fNewBorder));
 258
 259                 // clip
 260                 if(nNewBorder < 0L)
 261                 {
 262                     nNewBorder = 0L;
 263                 }
 264
 265                 if(nNewBorder > 100L)
 266                 {
 267                     nNewBorder = 100L;
 268                 }
 269
 270                 // set
 271                 if(nNewBorder != rG.aGradient.GetBorder())
 272                 {
 273                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 274                 }
 275             }
 276
 277             break;
 278         }
 279         case css::awt::GradientStyle_AXIAL :
 280         {
 281             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 282             {
 283                 basegfx::B2DVector aFullVec(aEndPos - aCenter);
 284                 const basegfx::B2DVector aOldVec(basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()) - aCenter);
 285                 const double fFullLen(aFullVec.getLength());
 286                 const double fOldLen(aOldVec.getLength());
 287                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 288                 sal_Int32 nNewBorder = 100 - FRound(fNewBorder);
 289
 290                 // clip
 291                 if(nNewBorder < 0L)
 292                 {
 293                     nNewBorder = 0L;
 294                 }
 295
 296                 if(nNewBorder > 100L)
 297                 {
 298                     nNewBorder = 100L;
 299                 }
 300
 301                 // set
 302                 if(nNewBorder != rG.aGradient.GetBorder())
 303                 {
 304                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 305                 }
 306
 307                 aFullVec.normalize();
 308                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 309                 fNewFullAngle /= F_PI180;
 310                 fNewFullAngle *= -10.0;
 311                 fNewFullAngle += 900.0;
 312
 313                 // clip
 314                 while(fNewFullAngle < 0.0)
 315                 {
 316                     fNewFullAngle += 3600.0;
 317                 }
 318
 319                 while(fNewFullAngle >= 3600.0)
 320                 {
 321                     fNewFullAngle -= 3600.0;
 322                 }
 323
 324                 // to int and set
 325                 const sal_Int32 nNewAngle(FRound(fNewFullAngle));
 326
 327                 if(nNewAngle != rGOld.aGradient.GetAngle())
 328                 {
 329                     rG.aGradient.SetAngle(nNewAngle);
 330                 }
 331             }
 332
 333             break;
 334         }
 335         case css::awt::GradientStyle_RADIAL :
 336         case css::awt::GradientStyle_SQUARE :
 337         {
 338             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 339             {
 340                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 341                 const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
 342                 sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
 343                 sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));
 344
 345                 // clip
 346                 if(nNewXOffset < 0L)
 347                 {
 348                     nNewXOffset = 0L;
 349                 }
 350
 351                 if(nNewXOffset > 100L)
 352                 {
 353                     nNewXOffset = 100L;
 354                 }
 355
 356                 if(nNewYOffset < 0L)
 357                 {
 358                     nNewYOffset = 0L;
 359                 }
 360
 361                 if(nNewYOffset > 100L)
 362                 {
 363                     nNewYOffset = 100L;
 364                 }
 365
 366                 rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
 367                 rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);
 368
 369                 aStartPos -= aOffset;
 370                 aEndPos -= aOffset;
 371             }
 372
 373             if(!bMoveSingle || (bMoveSingle && bMoveFirst))
 374             {
 375                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
 376                 const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
 377                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 378                 const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
 379                 const double fFullLen(aFullVec.getLength());
 380                 const double fOldLen(aOldVec.getLength());
 381                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 382                 sal_Int32 nNewBorder(100L - FRound(fNewBorder));
 383
 384                 // clip
 385                 if(nNewBorder < 0L)
 386                 {
 387                     nNewBorder = 0L;
 388                 }
 389
 390                 if(nNewBorder > 100L)
 391                 {
 392                     nNewBorder = 100L;
 393                 }
 394
 395                 // set
 396                 if(nNewBorder != rG.aGradient.GetBorder())
 397                 {
 398                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 399                 }
 400
 401                 // angle is not definitely necessary for these modes, but it makes
 402                 // controlling more fun for the user
 403                 aFullVec.normalize();
 404                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 405                 fNewFullAngle /= F_PI180;
 406                 fNewFullAngle *= -10.0;
 407                 fNewFullAngle += 900.0;
 408
 409                 // clip
 410                 while(fNewFullAngle < 0.0)
 411                 {
 412                     fNewFullAngle += 3600.0;
 413                 }
 414
 415                 while(fNewFullAngle >= 3600.0)
 416                 {
 417                     fNewFullAngle -= 3600.0;
 418                 }
 419
 420                 // to int and set
 421                 const sal_Int32 nNewAngle(FRound(fNewFullAngle));
 422
 423                 if(nNewAngle != rGOld.aGradient.GetAngle())
 424                 {
 425                     rG.aGradient.SetAngle(nNewAngle);
 426                 }
 427             }
 428
 429             break;
 430         }
 431         case css::awt::GradientStyle_ELLIPTICAL :
 432         case css::awt::GradientStyle_RECT :
 433         {
 434             if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
 435             {
 436                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 437                 const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
 438                 sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
 439                 sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));
 440
 441                 // clip
 442                 if(nNewXOffset < 0L)
 443                 {
 444                     nNewXOffset = 0L;
 445                 }
 446
 447                 if(nNewXOffset > 100L)
 448                 {
 449                     nNewXOffset = 100L;
 450                 }
 451
 452                 if(nNewYOffset < 0L)
 453                 {
 454                     nNewYOffset = 0L;
 455                 }
 456
 457                 if(nNewYOffset > 100L)
 458                 {
 459                     nNewYOffset = 100L;
 460                 }
 461
 462                 rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
 463                 rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);
 464
 465                 aStartPos -= aOffset;
 466                 aEndPos -= aOffset;
 467             }
 468
 469             if(!bMoveSingle || (bMoveSingle && bMoveFirst))
 470             {
 471                 basegfx::B2DVector aFullVec(aStartPos - aEndPos);
 472                 const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
 473                 const basegfx::B2DPoint aCenterLeft(aRange.getMinX(), aCenter.getY());
 474                 const basegfx::B2DVector aOldVec(aCenterLeft - aTopLeft);
 475                 const double fFullLen(aFullVec.getLength());
 476                 const double fOldLen(aOldVec.getLength());
 477                 const double fNewBorder((fFullLen * 100.0) / fOldLen);
 478                 sal_Int32 nNewBorder(100L - FRound(fNewBorder));
 479
 480                 // clip
 481                 if(nNewBorder < 0L)
 482                 {
 483                     nNewBorder = 0L;
 484                 }
 485
 486                 if(nNewBorder > 100L)
 487                 {
 488                     nNewBorder = 100L;
 489                 }
 490
 491                 // set
 492                 if(nNewBorder != rG.aGradient.GetBorder())
 493                 {
 494                     rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
 495                 }
 496
 497                 // angle is not definitely necessary for these modes, but it makes
 498                 // controlling more fun for the user
 499                 aFullVec.normalize();
 500                 double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
 501                 fNewFullAngle /= F_PI180;
 502                 fNewFullAngle *= -10.0;
 503                 fNewFullAngle += 900.0;
 504
 505                 // clip
 506                 while(fNewFullAngle < 0.0)
 507                 {
 508                     fNewFullAngle += 3600.0;
 509                 }
 510
 511                 while(fNewFullAngle >= 3600.0)
 512                 {
 513                     fNewFullAngle -= 3600.0;
 514                 }
 515
 516                 // to int and set
 517                 const sal_Int32 nNewAngle(FRound(fNewFullAngle));
 518
 519                 if(nNewAngle != rGOld.aGradient.GetAngle())
 520                 {
 521                     rG.aGradient.SetAngle(nNewAngle);
 522                 }
 523             }
 524
 525             break;
 526         }
 527         default:
 528             break;
 529     }
 530 }
 531
 532 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */