2015-07-09 18:46:29 -04:00
|
|
|
/* ====================================================================
|
|
|
|
Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
contributor license agreements. See the NOTICE file distributed with
|
|
|
|
this work for additional information regarding copyright ownership.
|
|
|
|
The ASF licenses this file to You under the Apache License, Version 2.0
|
|
|
|
(the "License"); you may not use this file except in compliance with
|
|
|
|
the License. You may obtain a copy of the License at
|
|
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
See the License for the specific language governing permissions and
|
|
|
|
limitations under the License.
|
|
|
|
==================================================================== */
|
|
|
|
|
2015-02-21 05:56:03 -05:00
|
|
|
package org.apache.poi.sl.draw;
|
|
|
|
|
|
|
|
import java.awt.Graphics2D;
|
|
|
|
import java.awt.geom.AffineTransform;
|
|
|
|
import java.awt.geom.Rectangle2D;
|
|
|
|
|
|
|
|
import org.apache.poi.sl.usermodel.PlaceableShape;
|
|
|
|
import org.apache.poi.sl.usermodel.Shape;
|
|
|
|
|
|
|
|
|
2015-08-24 19:15:14 -04:00
|
|
|
public class DrawShape implements Drawable {
|
2015-02-21 05:56:03 -05:00
|
|
|
|
2015-08-24 19:15:14 -04:00
|
|
|
protected final Shape<?,?> shape;
|
|
|
|
|
|
|
|
public DrawShape(Shape<?,?> shape) {
|
2015-02-21 05:56:03 -05:00
|
|
|
this.shape = shape;
|
|
|
|
}
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-02-21 05:56:03 -05:00
|
|
|
/**
|
|
|
|
* Apply 2-D transforms before drawing this shape. This includes rotation and flipping.
|
|
|
|
*
|
|
|
|
* @param graphics the graphics whos transform matrix will be modified
|
|
|
|
*/
|
|
|
|
public void applyTransform(Graphics2D graphics) {
|
2015-03-07 18:35:40 -05:00
|
|
|
if (!(shape instanceof PlaceableShape)) return;
|
2015-08-24 19:15:14 -04:00
|
|
|
|
|
|
|
PlaceableShape<?,?> ps = (PlaceableShape<?,?>)shape;
|
2015-02-21 05:56:03 -05:00
|
|
|
AffineTransform tx = (AffineTransform)graphics.getRenderingHint(Drawable.GROUP_TRANSFORM);
|
2015-06-13 19:26:46 -04:00
|
|
|
if (tx == null) tx = new AffineTransform();
|
|
|
|
final Rectangle2D anchor = tx.createTransformedShape(ps.getAnchor()).getBounds2D();
|
2015-02-21 05:56:03 -05:00
|
|
|
|
|
|
|
// rotation
|
2015-03-07 18:35:40 -05:00
|
|
|
double rotation = ps.getRotation();
|
2015-02-21 05:56:03 -05:00
|
|
|
if (rotation != 0.) {
|
|
|
|
// PowerPoint rotates shapes relative to the geometric center
|
|
|
|
double centerX = anchor.getCenterX();
|
|
|
|
double centerY = anchor.getCenterY();
|
|
|
|
|
|
|
|
// normalize rotation
|
2015-06-10 18:23:47 -04:00
|
|
|
rotation %= 360.;
|
|
|
|
if (rotation < 0) rotation += 360.;
|
2015-06-13 19:26:46 -04:00
|
|
|
|
2015-02-21 05:56:03 -05:00
|
|
|
int quadrant = (((int)rotation+45)/90)%4;
|
|
|
|
double scaleX = 1.0, scaleY = 1.0;
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-02-21 05:56:03 -05:00
|
|
|
// scale to bounding box (bug #53176)
|
|
|
|
if (quadrant == 1 || quadrant == 3) {
|
2015-08-24 19:15:14 -04:00
|
|
|
// In quadrant 1 and 3, which is basically a shape in a more or less portrait orientation
|
|
|
|
// (45-135 degrees and 225-315 degrees), we need to first rotate the shape by a multiple
|
|
|
|
// of 90 degrees and then resize the bounding box to its original bbox. After that we can
|
2015-02-21 05:56:03 -05:00
|
|
|
// rotate the shape to the exact rotation amount.
|
|
|
|
// It's strange that you'll need to rotate the shape back and forth again, but you can
|
|
|
|
// think of it, as if you paint the shape on a canvas. First you rotate the canvas, which might
|
|
|
|
// be already (differently) scaled, so you can paint the shape in its default orientation
|
|
|
|
// and later on, turn it around again to compare it with its original size ...
|
2015-06-10 18:23:47 -04:00
|
|
|
|
2015-06-13 19:26:46 -04:00
|
|
|
AffineTransform txs;
|
2015-07-19 15:00:32 -04:00
|
|
|
if (ps.getClass().getCanonicalName().toLowerCase().contains("hslf")) {
|
2015-06-13 19:26:46 -04:00
|
|
|
txs = new AffineTransform(tx);
|
|
|
|
} else {
|
|
|
|
// this handling is only based on try and error ... not sure why xslf is handled differently.
|
|
|
|
txs = new AffineTransform();
|
2015-06-10 18:23:47 -04:00
|
|
|
txs.translate(centerX, centerY);
|
2015-06-13 19:26:46 -04:00
|
|
|
txs.rotate(Math.PI/2.); // actually doesn't matter if +/- 90 degrees
|
2015-06-10 18:23:47 -04:00
|
|
|
txs.translate(-centerX, -centerY);
|
2015-06-13 19:26:46 -04:00
|
|
|
txs.concatenate(tx);
|
2015-06-10 18:23:47 -04:00
|
|
|
}
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-06-13 19:26:46 -04:00
|
|
|
txs.translate(centerX, centerY);
|
|
|
|
txs.rotate(Math.PI/2.);
|
|
|
|
txs.translate(-centerX, -centerY);
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-06-13 19:26:46 -04:00
|
|
|
Rectangle2D anchor2 = txs.createTransformedShape(ps.getAnchor()).getBounds2D();
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-02-21 05:56:03 -05:00
|
|
|
scaleX = anchor.getWidth() == 0. ? 1.0 : anchor.getWidth() / anchor2.getWidth();
|
|
|
|
scaleY = anchor.getHeight() == 0. ? 1.0 : anchor.getHeight() / anchor2.getHeight();
|
2015-06-10 18:23:47 -04:00
|
|
|
} else {
|
2015-06-13 19:26:46 -04:00
|
|
|
quadrant = 0;
|
2015-02-21 05:56:03 -05:00
|
|
|
}
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-02-21 05:56:03 -05:00
|
|
|
// transformation is applied reversed ...
|
2015-06-13 19:26:46 -04:00
|
|
|
graphics.translate(centerX, centerY);
|
|
|
|
graphics.rotate(Math.toRadians(rotation-quadrant*90.));
|
|
|
|
graphics.scale(scaleX, scaleY);
|
|
|
|
graphics.rotate(Math.toRadians(quadrant*90));
|
|
|
|
graphics.translate(-centerX, -centerY);
|
2015-02-21 05:56:03 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
//flip horizontal
|
2015-03-07 18:35:40 -05:00
|
|
|
if (ps.getFlipHorizontal()) {
|
2015-02-21 05:56:03 -05:00
|
|
|
graphics.translate(anchor.getX() + anchor.getWidth(), anchor.getY());
|
|
|
|
graphics.scale(-1, 1);
|
|
|
|
graphics.translate(-anchor.getX(), -anchor.getY());
|
|
|
|
}
|
|
|
|
|
|
|
|
//flip vertical
|
2015-03-07 18:35:40 -05:00
|
|
|
if (ps.getFlipVertical()) {
|
2015-02-21 05:56:03 -05:00
|
|
|
graphics.translate(anchor.getX(), anchor.getY() + anchor.getHeight());
|
|
|
|
graphics.scale(1, -1);
|
|
|
|
graphics.translate(-anchor.getX(), -anchor.getY());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public void draw(Graphics2D graphics) {
|
|
|
|
}
|
|
|
|
|
2015-08-24 19:15:14 -04:00
|
|
|
public void drawContent(Graphics2D graphics) {
|
2015-02-21 05:56:03 -05:00
|
|
|
}
|
2015-03-07 18:35:40 -05:00
|
|
|
|
2015-08-24 19:15:14 -04:00
|
|
|
public static Rectangle2D getAnchor(Graphics2D graphics, PlaceableShape<?,?> shape) {
|
2015-03-07 18:35:40 -05:00
|
|
|
return getAnchor(graphics, shape.getAnchor());
|
|
|
|
}
|
2015-08-24 19:15:14 -04:00
|
|
|
|
2015-03-07 18:35:40 -05:00
|
|
|
public static Rectangle2D getAnchor(Graphics2D graphics, Rectangle2D anchor) {
|
2015-02-21 05:56:03 -05:00
|
|
|
if(graphics == null) {
|
|
|
|
return anchor;
|
|
|
|
}
|
|
|
|
|
|
|
|
AffineTransform tx = (AffineTransform)graphics.getRenderingHint(Drawable.GROUP_TRANSFORM);
|
|
|
|
if(tx != null) {
|
|
|
|
anchor = tx.createTransformedShape(anchor).getBounds2D();
|
|
|
|
}
|
|
|
|
return anchor;
|
2015-08-24 19:15:14 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
protected Shape<?,?> getShape() {
|
|
|
|
return shape;
|
|
|
|
}
|
2015-02-21 05:56:03 -05:00
|
|
|
}
|