rev 11020 : 8201563: Update copyright header for files modified in 2018
Reviewed-by:

   1 /*
   2  * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javafx.scene.transform;
  27 
  28 import javafx.beans.property.DoubleProperty;
  29 import javafx.beans.property.DoublePropertyBase;
  30 
  31 import com.sun.javafx.geom.transform.Affine3D;
  32 import com.sun.javafx.geom.transform.BaseTransform;
  33 import javafx.geometry.Point2D;
  34 import javafx.geometry.Point3D;
  35 
  36 
  37 /**
  38  * This class represents an {@code Affine} object that shears coordinates
  39  * by the specified multipliers. The matrix representing the shearing transformation
  40  * around a pivot point {@code (pivotX, pivotY)} with multiplication factors {@code x}
  41  * and {@code y} is as follows:
  42  * <pre>
  43  *              [   1   x   0   -x*pivotY   ]
  44  *              [   y   1   0   -y*pivotX   ]
  45  *              [   0   0   1       0       ]
  46  * </pre>
  47  *
  48  * <p>
  49  * For example:
  50  * <pre>{@code
  51  * Text text = new Text("Using Shear for pseudo-italic font");
  52  * text.setX(20);
  53  * text.setY(50);
  54  * text.setFont(new Font(20));
  55  *
  56  * text.getTransforms().add(new Shear(-0.35, 0));
  57  * }</pre>
  58  *
  59  * @since JavaFX 2.0
  60  */
  61 public class Shear extends Transform {
  62 
  63     /**
  64      * Creates a default Shear (identity).
  65      */
  66     public Shear() {
  67     }
  68 
  69     /**
  70      * Creates a new instance of Shear.
  71      * The pivot point is set to (0,0)
  72      * @param x the multiplier by which coordinates are shifted in the direction
  73      * of the positive X axis as a factor of their Y coordinate
  74      * @param y the multiplier by which coordinates are shifted in the direction
  75      * of the positive Y axis as a factor of their X coordinate
  76      */
  77     public Shear(double x, double y) {
  78         setX(x);
  79         setY(y);
  80     }
  81 
  82     /**
  83      * Creates a new instance of Shear with pivot.
  84      * @param x the multiplier by which coordinates are shifted in the direction
  85      * of the positive X axis as a factor of their Y coordinate
  86      * @param y the multiplier by which coordinates are shifted in the direction
  87      * of the positive Y axis as a factor of their X coordinate
  88      * @param pivotX the X coordinate of the shear pivot point
  89      * @param pivotY the Y coordinate of the shear pivot point
  90      */
  91     public Shear(double x, double y, double pivotX, double pivotY) {
  92         setX(x);
  93         setY(y);
  94         setPivotX(pivotX);
  95         setPivotY(pivotY);
  96     }
  97 
  98     /**
  99      * Defines the multiplier by which coordinates are shifted in the direction
 100      * of the positive X axis as a factor of their Y coordinate. Typical values
 101      * are in the range -1 to 1, exclusive.
 102      *
 103      * @defaultValue 0.0
 104      */
 105     private DoubleProperty x;
 106 
 107 
 108     public final void setX(double value) {
 109         xProperty().set(value);
 110     }
 111 
 112     public final double getX() {
 113         return x == null ? 0.0 : x.get();
 114     }
 115 
 116     public final DoubleProperty xProperty() {
 117         if (x == null) {
 118             x = new DoublePropertyBase() {
 119 
 120                 @Override
 121                 public void invalidated() {
 122                     transformChanged();
 123                 }
 124 
 125                 @Override
 126                 public Object getBean() {
 127                     return Shear.this;
 128                 }
 129 
 130                 @Override
 131                 public String getName() {
 132                     return "x";
 133                 }
 134             };
 135         }
 136         return x;
 137     }
 138 
 139     /**
 140      * Defines the multiplier by which coordinates are shifted in the direction
 141      * of the positive Y axis as a factor of their X coordinate. Typical values
 142      * are in the range -1 to 1, exclusive.
 143      *
 144      * @defaultValue 0.0
 145      */
 146     private DoubleProperty y;
 147 
 148 
 149     public final void setY(double value) {
 150         yProperty().set(value);
 151     }
 152 
 153     public final double getY() {
 154         return y == null ? 0.0 : y.get();
 155     }
 156 
 157     public final DoubleProperty yProperty() {
 158         if (y == null) {
 159             y = new DoublePropertyBase() {
 160 
 161                 @Override
 162                 public void invalidated() {
 163                     transformChanged();
 164                 }
 165 
 166                 @Override
 167                 public Object getBean() {
 168                     return Shear.this;
 169                 }
 170 
 171                 @Override
 172                 public String getName() {
 173                     return "y";
 174                 }
 175             };
 176         }
 177         return y;
 178     }
 179 
 180     /**
 181      * Defines the X coordinate of the shear pivot point.
 182      *
 183      * @defaultValue 0.0
 184      */
 185     private DoubleProperty pivotX;
 186 
 187 
 188     public final void setPivotX(double value) {
 189         pivotXProperty().set(value);
 190     }
 191 
 192     public final double getPivotX() {
 193         return pivotX == null ? 0.0 : pivotX.get();
 194     }
 195 
 196     public final DoubleProperty pivotXProperty() {
 197         if (pivotX == null) {
 198             pivotX = new DoublePropertyBase() {
 199 
 200                 @Override
 201                 public void invalidated() {
 202                     transformChanged();
 203                 }
 204 
 205                 @Override
 206                 public Object getBean() {
 207                     return Shear.this;
 208                 }
 209 
 210                 @Override
 211                 public String getName() {
 212                     return "pivotX";
 213                 }
 214             };
 215         }
 216         return pivotX;
 217     }
 218 
 219     /**
 220      * Defines the Y coordinate of the shear pivot point.
 221      *
 222      * @defaultValue 0.0
 223      */
 224     private DoubleProperty pivotY;
 225 
 226 
 227     public final void setPivotY(double value) {
 228         pivotYProperty().set(value);
 229     }
 230 
 231     public final double getPivotY() {
 232         return pivotY == null ? 0.0 : pivotY.get();
 233     }
 234 
 235     public final DoubleProperty pivotYProperty() {
 236         if (pivotY == null) {
 237             pivotY = new DoublePropertyBase() {
 238 
 239                 @Override
 240                 public void invalidated() {
 241                     transformChanged();
 242                 }
 243 
 244                 @Override
 245                 public Object getBean() {
 246                     return Shear.this;
 247                 }
 248 
 249                 @Override
 250                 public String getName() {
 251                     return "pivotY";
 252                 }
 253             };
 254         }
 255         return pivotY;
 256     }
 257 
 258     /* *************************************************************************
 259      *                                                                         *
 260      *                         Element getters                                 *
 261      *                                                                         *
 262      **************************************************************************/
 263 
 264     @Override
 265     public double getMxy() {
 266         return getX();
 267     }
 268 
 269     @Override
 270     public double getMyx() {
 271         return getY();
 272     }
 273 
 274     @Override
 275     public double getTx() {
 276         return -getX() * getPivotY();
 277     }
 278 
 279     @Override
 280     public double getTy() {
 281         return -getY() * getPivotX();
 282     }
 283 
 284     /* *************************************************************************
 285      *                                                                         *
 286      *                           State getters                                 *
 287      *                                                                         *
 288      **************************************************************************/
 289 
 290     @Override
 291     boolean computeIs2D() {
 292         return true;
 293     }
 294 
 295     @Override
 296     boolean computeIsIdentity() {
 297         return getX() == 0.0 && getY() == 0.0;
 298     }
 299 
 300     /* *************************************************************************
 301      *                                                                         *
 302      *                           Array getters                                 *
 303      *                                                                         *
 304      **************************************************************************/
 305 
 306     @Override
 307     void fill2DArray(double[] array) {
 308         final double sx = getX();
 309         final double sy = getY();
 310 
 311         array[0] = 1.0;
 312         array[1] = sx;
 313         array[2] = -sx * getPivotY();
 314         array[3] = sy;
 315         array[4] = 1.0;
 316         array[5] = -sy * getPivotX();
 317     }
 318 
 319     @Override
 320     void fill3DArray(double[] array) {
 321         final double sx = getX();
 322         final double sy = getY();
 323 
 324         array[0] = 1.0;
 325         array[1] = sx;
 326         array[2] = 0.0;
 327         array[3] = -sx * getPivotY();
 328         array[4] = sy;
 329         array[5] = 1.0;
 330         array[6] = 0.0;
 331         array[7] = -sy * getPivotX();
 332         array[8] = 0.0;
 333         array[9] = 0.0;
 334         array[10] = 1.0;
 335         array[11] = 0.0;
 336     }
 337 
 338     /* *************************************************************************
 339      *                                                                         *
 340      *                         Transform creators                              *
 341      *                                                                         *
 342      **************************************************************************/
 343 
 344     @Override
 345     public Transform createConcatenation(Transform transform) {
 346 
 347         if (transform instanceof Affine) {
 348             Affine a = (Affine) transform.clone();
 349             a.prepend(this);
 350             return a;
 351         }
 352 
 353         final double sx = getX();
 354         final double sy = getY();
 355 
 356         final double txx = transform.getMxx();
 357         final double txy = transform.getMxy();
 358         final double txz = transform.getMxz();
 359         final double ttx = transform.getTx();
 360         final double tyx = transform.getMyx();
 361         final double tyy = transform.getMyy();
 362         final double tyz = transform.getMyz();
 363         final double tty = transform.getTy();
 364         return new Affine(
 365                 txx + sx * tyx,
 366                 txy + sx * tyy,
 367                 txz + sx * tyz,
 368                 ttx + sx * tty - sx * getPivotY(),
 369                 sy * txx + tyx,
 370                 sy * txy + tyy,
 371                 sy * txz + tyz,
 372                 sy * ttx + tty - sy * getPivotX(),
 373                 transform.getMzx(),
 374                 transform.getMzy(),
 375                 transform.getMzz(),
 376                 transform.getTz());
 377     }
 378 
 379     @Override
 380     public Transform createInverse() {
 381         final double sx = getX();
 382         final double sy = getY();
 383 
 384         if (sy == 0.0) {
 385             return new Shear(-sx, 0.0, 0.0, getPivotY());
 386         }
 387 
 388         if (sx == 0.0) {
 389             return new Shear(0.0, -sy, getPivotX(), 0.0);
 390         }
 391 
 392         final double px = getPivotX();
 393         final double py = getPivotY();
 394         final double coef = 1.0 / (1.0 - sx * sy);
 395 
 396         return new Affine(
 397                 coef,       -sx * coef,         0, sx * (py - sy * px) * coef,
 398                 -sy * coef, 1 + sx * sy * coef, 0, sy * px + sy * (sx * sy * px - sx * py) * coef,
 399                 0,          0,                  1, 0);
 400     }
 401 
 402     @Override
 403     public Shear clone() {
 404         return new Shear(getX(), getY(), getPivotX(), getPivotY());
 405     }
 406 
 407     /* *************************************************************************
 408      *                                                                         *
 409      *                     Transform, Inverse Transform                        *
 410      *                                                                         *
 411      **************************************************************************/
 412 
 413     @Override
 414     public Point2D transform(double x, double y) {
 415         final double mxy = getX();
 416         final double myx = getY();
 417 
 418         return new Point2D(
 419             x + mxy * y - mxy * getPivotY(),
 420             myx * x + y - myx * getPivotX());
 421     }
 422 
 423     @Override
 424     public Point3D transform(double x, double y, double z) {
 425         final double mxy = getX();
 426         final double myx = getY();
 427 
 428         return new Point3D(
 429             x + mxy * y - mxy * getPivotY(),
 430             myx * x + y - myx * getPivotX(),
 431             z);
 432     }
 433 
 434     @Override
 435     void transform2DPointsImpl(double[] srcPts, int srcOff,
 436             double[] dstPts, int dstOff, int numPts) {
 437         final double xy = getX();
 438         final double yx = getY();
 439         final double px = getPivotX();
 440         final double py = getPivotY();
 441 
 442         while (--numPts >= 0) {
 443             final double x = srcPts[srcOff++];
 444             final double y = srcPts[srcOff++];
 445 
 446             dstPts[dstOff++] = x + xy * y - xy * py;
 447             dstPts[dstOff++] = yx * x + y - yx * px;
 448         }
 449     }
 450 
 451     @Override
 452     void transform3DPointsImpl(double[] srcPts, int srcOff,
 453             double[] dstPts, int dstOff, int numPts) {
 454         final double xy = getX();
 455         final double yx = getY();
 456         final double px = getPivotX();
 457         final double py = getPivotY();
 458 
 459         while (--numPts >= 0) {
 460             final double x = srcPts[srcOff++];
 461             final double y = srcPts[srcOff++];
 462 
 463             dstPts[dstOff++] = x + xy * y - xy * py;
 464             dstPts[dstOff++] = yx * x + y - yx * px;
 465             dstPts[dstOff++] = srcPts[srcOff++];
 466         }
 467     }
 468 
 469     @Override
 470     public Point2D deltaTransform(double x, double y) {
 471 
 472         return new Point2D(
 473             x + getX() * y,
 474             getY() * x + y);
 475     }
 476 
 477     @Override
 478     public Point3D deltaTransform(double x, double y, double z) {
 479         return new Point3D(
 480             x + getX() * y,
 481             getY() * x + y,
 482             z);
 483     }
 484 
 485 
 486     @Override
 487     public Point2D inverseTransform(double x, double y)
 488             throws NonInvertibleTransformException {
 489         final double sx = getX();
 490         final double sy = getY();
 491 
 492         if (sy == 0.0) {
 493             final double mxy = -getX();
 494 
 495             return new Point2D(
 496                 x + mxy * y - mxy * getPivotY(),
 497                 y);
 498         }
 499 
 500         if (sx == 0.0) {
 501             final double myx = -getY();
 502 
 503             return new Point2D(
 504                 x,
 505                 myx * x + y - myx * getPivotX());
 506         }
 507 
 508         return super.inverseTransform(x, y);
 509     }
 510 
 511     @Override
 512     public Point3D inverseTransform(double x, double y, double z)
 513             throws NonInvertibleTransformException {
 514         final double sx = getX();
 515         final double sy = getY();
 516 
 517         if (sy == 0.0) {
 518             final double mxy = -getX();
 519 
 520             return new Point3D(
 521                 x + mxy * y - mxy * getPivotY(),
 522                 y,
 523                 z);
 524         }
 525 
 526         if (sx == 0.0) {
 527             final double myx = -getY();
 528 
 529             return new Point3D(
 530                 x,
 531                 myx * x + y - myx * getPivotX(),
 532                 z);
 533         }
 534 
 535         return super.inverseTransform(x, y, z);
 536     }
 537 
 538     @Override
 539     void inverseTransform2DPointsImpl(double[] srcPts, int srcOff,
 540             double[] dstPts, int dstOff, int numPts)
 541             throws NonInvertibleTransformException {
 542 
 543         final double px = getPivotX();
 544         final double py = getPivotY();
 545 
 546         final double sx = getX();
 547         final double sy = getY();
 548 
 549         if (sy == 0.0) {
 550             final double xy = -sx;
 551 
 552             while (--numPts >= 0) {
 553                 final double x = srcPts[srcOff++];
 554                 final double y = srcPts[srcOff++];
 555 
 556                 dstPts[dstOff++] = x + xy * y - xy * py;
 557                 dstPts[dstOff++] = y;
 558             }
 559             return;
 560         }
 561 
 562         if (sx == 0.0) {
 563             final double yx = -sy;
 564 
 565             while (--numPts >= 0) {
 566                 final double x = srcPts[srcOff++];
 567                 final double y = srcPts[srcOff++];
 568 
 569                 dstPts[dstOff++] = x;
 570                 dstPts[dstOff++] = yx * x + y - yx * px;
 571             }
 572             return;
 573         }
 574 
 575         super.inverseTransform2DPointsImpl(srcPts, srcOff, dstPts, dstOff, numPts);
 576     }
 577 
 578     @Override
 579     void inverseTransform3DPointsImpl(double[] srcPts, int srcOff,
 580             double[] dstPts, int dstOff, int numPts)
 581             throws NonInvertibleTransformException{
 582 
 583         final double px = getPivotX();
 584         final double py = getPivotY();
 585 
 586         final double sx = getX();
 587         final double sy = getY();
 588 
 589         if (sy == 0.0) {
 590             final double xy = -sx;
 591 
 592             while (--numPts >= 0) {
 593                 final double x = srcPts[srcOff++];
 594                 final double y = srcPts[srcOff++];
 595 
 596                 dstPts[dstOff++] = x + xy * y - xy * py;
 597                 dstPts[dstOff++] = y;
 598                 dstPts[dstOff++] = srcPts[srcOff++];
 599             }
 600             return;
 601         }
 602 
 603         if (sx == 0.0) {
 604             final double yx = -sy;
 605 
 606             while (--numPts >= 0) {
 607                 final double x = srcPts[srcOff++];
 608                 final double y = srcPts[srcOff++];
 609 
 610                 dstPts[dstOff++] = x;
 611                 dstPts[dstOff++] = yx * x + y - yx * px;
 612                 dstPts[dstOff++] = srcPts[srcOff++];
 613             }
 614             return;
 615         }
 616 
 617         super.inverseTransform3DPointsImpl(srcPts, srcOff, dstPts, dstOff, numPts);
 618     }
 619 
 620     @Override
 621     public Point2D inverseDeltaTransform(double x, double y)
 622             throws NonInvertibleTransformException {
 623         final double sx = getX();
 624         final double sy = getY();
 625 
 626         if (sy == 0.0) {
 627             return new Point2D(
 628                 x - getX() * y,
 629                 y);
 630         }
 631 
 632         if (sx == 0.0) {
 633             return new Point2D(
 634                 x,
 635                 -getY() * x + y);
 636         }
 637 
 638         return super.inverseDeltaTransform(x, y);
 639     }
 640 
 641     @Override
 642     public Point3D inverseDeltaTransform(double x, double y, double z)
 643             throws NonInvertibleTransformException {
 644         final double sx = getX();
 645         final double sy = getY();
 646 
 647         if (sy == 0.0) {
 648             return new Point3D(
 649                 x - getX() * y,
 650                 y,
 651                 z);
 652         }
 653 
 654         if (sx == 0.0) {
 655             return new Point3D(
 656                 x,
 657                 -getY() * x + y,
 658                 z);
 659         }
 660 
 661         return super.inverseDeltaTransform(x, y, z);
 662     }
 663 
 664     /* *************************************************************************
 665      *                                                                         *
 666      *                               Other API                                 *
 667      *                                                                         *
 668      **************************************************************************/
 669 
 670     /**
 671      * Returns a string representation of this {@code Shear} object.
 672      * @return a string representation of this {@code Shear} object.
 673      */
 674     @Override
 675     public String toString() {
 676         final StringBuilder sb = new StringBuilder("Shear [");
 677 
 678         sb.append("x=").append(getX());
 679         sb.append(", y=").append(getY());
 680         sb.append(", pivotX=").append(getPivotX());
 681         sb.append(", pivotY=").append(getPivotY());
 682 
 683         return sb.append("]").toString();
 684     }
 685 
 686     /* *************************************************************************
 687      *                                                                         *
 688      *                    Internal implementation stuff                        *
 689      *                                                                         *
 690      **************************************************************************/
 691 
 692     @Override
 693     void apply(final Affine3D trans) {
 694         if (getPivotX() != 0 || getPivotY() != 0) {
 695             trans.translate(getPivotX(), getPivotY());
 696             trans.shear(getX(), getY());
 697             trans.translate(-getPivotX(), -getPivotY());
 698         } else {
 699             trans.shear(getX(), getY());
 700         }
 701     }
 702 
 703     @Override
 704     BaseTransform derive(final BaseTransform trans) {
 705         return trans.deriveWithConcatenation(
 706                 1.0, getY(),
 707                 getX(), 1.0,
 708                 getTx(), getTy());
 709     }
 710 
 711     @Override
 712     void validate() {
 713         getX(); getPivotX();
 714         getY(); getPivotY();
 715     }
 716 
 717     @Override
 718     void appendTo(Affine a) {
 719         a.appendShear(getX(), getY(), getPivotX(), getPivotY());
 720     }
 721 
 722     @Override
 723     void prependTo(Affine a) {
 724         a.prependShear(getX(), getY(), getPivotX(), getPivotY());
 725     }
 726 }
--- EOF ---