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