下面列出了java.awt.geom.Rectangle2D#getMaxX ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Draws a domain crosshair.
*
* @param g2 the graphics target.
* @param dataArea the data area.
* @param orientation the plot orientation.
* @param value the crosshair value.
* @param axis the axis against which the value is measured.
* @param stroke the stroke used to draw the crosshair line.
* @param paint the paint used to draw the crosshair line.
*
* @since 1.0.4
*/
protected void drawDomainCrosshair(Graphics2D g2, Rectangle2D dataArea,
PlotOrientation orientation, double value, ValueAxis axis,
Stroke stroke, Paint paint) {
if (axis.getRange().contains(value)) {
Line2D line = null;
if (orientation == PlotOrientation.VERTICAL) {
double xx = axis.valueToJava2D(value, dataArea,
RectangleEdge.BOTTOM);
line = new Line2D.Double(xx, dataArea.getMinY(), xx,
dataArea.getMaxY());
}
else {
double yy = axis.valueToJava2D(value, dataArea,
RectangleEdge.LEFT);
line = new Line2D.Double(dataArea.getMinX(), yy,
dataArea.getMaxX(), yy);
}
g2.setStroke(stroke);
g2.setPaint(paint);
g2.draw(line);
}
}
/**
* Draws a vertical line used to trace the mouse position to the horizontal
* axis.
*
* @param x the x-coordinate of the trace line.
*/
private void drawHorizontalAxisTrace(int x) {
Graphics2D g2 = (Graphics2D) getGraphics();
Rectangle2D dataArea = getScreenDataArea();
g2.setXORMode(java.awt.Color.orange);
if (((int) dataArea.getMinX() < x) && (x < (int) dataArea.getMaxX())) {
if (this.verticalTraceLine != null) {
g2.draw(this.verticalTraceLine);
this.verticalTraceLine.setLine(x, (int) dataArea.getMinY(), x,
(int) dataArea.getMaxY());
}
else {
this.verticalTraceLine = new Line2D.Float(x,
(int) dataArea.getMinY(), x, (int) dataArea.getMaxY());
}
g2.draw(this.verticalTraceLine);
}
}
/**
* Utility method for drawing a line perpendicular to the range axis (used
* for crosshairs).
*
* @param g2 the graphics device.
* @param dataArea the area defined by the axes.
* @param value the data value.
* @param stroke the line stroke (<code>null</code> not permitted).
* @param paint the line paint (<code>null</code> not permitted).
*/
protected void drawRangeLine(Graphics2D g2, Rectangle2D dataArea,
double value, Stroke stroke, Paint paint) {
double java2D = getRangeAxis().valueToJava2D(value, dataArea,
getRangeAxisEdge());
Line2D line = null;
if (this.orientation == PlotOrientation.HORIZONTAL) {
line = new Line2D.Double(java2D, dataArea.getMinY(), java2D,
dataArea.getMaxY());
}
else if (this.orientation == PlotOrientation.VERTICAL) {
line = new Line2D.Double(dataArea.getMinX(), java2D,
dataArea.getMaxX(), java2D);
}
g2.setStroke(stroke);
g2.setPaint(paint);
g2.draw(line);
}
public Rectangle2D createItalicBounds() {
float ia = cm.italicAngle;
Rectangle2D lb = getLogicalBounds();
float l = (float)lb.getMinX();
float t = -cm.ascent;
float r = (float)lb.getMaxX();
float b = cm.descent;
if (ia != 0) {
if (ia > 0) {
l -= ia * (b - cm.ssOffset);
r -= ia * (t - cm.ssOffset);
} else {
l -= ia * (t - cm.ssOffset);
r -= ia * (b - cm.ssOffset);
}
}
return new Rectangle2D.Float(l, t, r - l, b - t);
}
/**
* @deprecated
* for polygon completely outside the clip area
* pass back a small box to be able to continue normal processing
* @param clipBounds
* @return
*/
private static ArrayList<Point2D> buildBox(Rectangle2D clipBounds) {
ArrayList<Point2D> box = new ArrayList();
try {
{
double ulx = 0, uly = 0, lrx = 0, lry = 0;
ulx = clipBounds.getMinX() - 200;
uly = clipBounds.getMinY() - 200;
lrx = clipBounds.getMaxX() + 200;
lry = clipBounds.getMaxY() + 200;
Point2D lr = new Point2D.Double(ulx, uly);
Point2D ll = new Point2D.Double(ulx - 10, uly);
Point2D ul = new Point2D.Double(ulx - 10, uly - 10);
Point2D ur = new Point2D.Double(ulx, uly - 10);
box.add(lr);
box.add(ll);
box.add(ul);
box.add(ur);
box.add(lr);
}
} catch (Exception exc) {
ErrorLogger.LogException(_className, "buildBox",
new RendererException("Failed inside buildBox", exc));
}
return box;
}
/**
* Draws a grid line against the domain axis.
* <P>
* Note that this default implementation assumes that the horizontal axis
* is the domain axis. If this is not the case, you will need to override
* this method.
*
* @param g2 the graphics device.
* @param plot the plot.
* @param dataArea the area for plotting data (not yet adjusted for any
* 3D effect).
* @param value the Java2D value at which the grid line should be drawn.
*
* @see #drawRangeGridline(Graphics2D, CategoryPlot, ValueAxis,
* Rectangle2D, double)
*/
@Override
public void drawDomainGridline(Graphics2D g2, CategoryPlot plot,
Rectangle2D dataArea, double value) {
Line2D line = null;
PlotOrientation orientation = plot.getOrientation();
if (orientation == PlotOrientation.HORIZONTAL) {
line = new Line2D.Double(dataArea.getMinX(), value,
dataArea.getMaxX(), value);
}
else if (orientation == PlotOrientation.VERTICAL) {
line = new Line2D.Double(value, dataArea.getMinY(), value,
dataArea.getMaxY());
}
Paint paint = plot.getDomainGridlinePaint();
if (paint == null) {
paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
}
g2.setPaint(paint);
Stroke stroke = plot.getDomainGridlineStroke();
if (stroke == null) {
stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
}
g2.setStroke(stroke);
g2.draw(line);
}
/**
* Draws a the title vertically within the specified area. This method
* will be called from the {@link #draw(Graphics2D, Rectangle2D) draw}
* method.
*
* @param g2 the graphics device.
* @param area the area for the title.
*/
protected void drawVertical(Graphics2D g2, Rectangle2D area) {
Rectangle2D titleArea = (Rectangle2D) area.clone();
g2.setFont(this.font);
g2.setPaint(this.paint);
TextBlockAnchor anchor = null;
float y = 0.0f;
VerticalAlignment verticalAlignment = getVerticalAlignment();
if (verticalAlignment == VerticalAlignment.TOP) {
y = (float) titleArea.getY();
anchor = TextBlockAnchor.TOP_RIGHT;
}
else if (verticalAlignment == VerticalAlignment.BOTTOM) {
y = (float) titleArea.getMaxY();
anchor = TextBlockAnchor.TOP_LEFT;
}
else if (verticalAlignment == VerticalAlignment.CENTER) {
y = (float) titleArea.getCenterY();
anchor = TextBlockAnchor.TOP_CENTER;
}
float x = 0.0f;
RectangleEdge position = getPosition();
if (position == RectangleEdge.LEFT) {
x = (float) titleArea.getX();
}
else if (position == RectangleEdge.RIGHT) {
x = (float) titleArea.getMaxX();
if (verticalAlignment == VerticalAlignment.TOP) {
anchor = TextBlockAnchor.BOTTOM_RIGHT;
}
else if (verticalAlignment == VerticalAlignment.CENTER) {
anchor = TextBlockAnchor.BOTTOM_CENTER;
}
else if (verticalAlignment == VerticalAlignment.BOTTOM) {
anchor = TextBlockAnchor.BOTTOM_LEFT;
}
}
this.content.draw(g2, x, y, anchor, x, y, -Math.PI / 2.0);
}
/**
* Converts a data value to a coordinate in Java2D space, assuming that
* the axis runs along one edge of the specified plotArea.
* Note that it is possible for the coordinate to fall outside the
* plotArea.
*
* @param value the data value.
* @param plotArea the area for plotting the data.
* @param edge the axis location.
*
* @return The Java2D coordinate.
*/
@Override
public double valueToJava2D(double value, Rectangle2D plotArea,
RectangleEdge edge) {
Range range = getRange();
double axisMin = switchedLog10(range.getLowerBound());
double axisMax = switchedLog10(range.getUpperBound());
double min = 0.0;
double max = 0.0;
if (RectangleEdge.isTopOrBottom(edge)) {
min = plotArea.getMinX();
max = plotArea.getMaxX();
}
else if (RectangleEdge.isLeftOrRight(edge)) {
min = plotArea.getMaxY();
max = plotArea.getMinY();
}
value = switchedLog10(value);
if (isInverted()) {
return max - (((value - axisMin) / (axisMax - axisMin))
* (max - min));
}
else {
return min + (((value - axisMin) / (axisMax - axisMin))
* (max - min));
}
}
protected double labelLocationX(AxisLabelLocation location,
Rectangle2D dataArea) {
if (location.equals(AxisLabelLocation.HIGH_END)) {
return dataArea.getMaxX();
}
if (location.equals(AxisLabelLocation.MIDDLE)) {
return dataArea.getCenterX();
}
if (location.equals(AxisLabelLocation.LOW_END)) {
return dataArea.getMinX();
}
throw new RuntimeException("Unexpected AxisLabelLocation: " + location);
}
/**
* Translates a (theta, radius) pair into Java2D coordinates. If
* <code>radius</code> is less than the lower bound of the axis, then
* this method returns the centre point.
*
* @param angleDegrees the angle in degrees.
* @param radius the radius.
* @param dataArea the data area.
*
* @return A point in Java2D space.
*/
public Point translateValueThetaRadiusToJava2D(double angleDegrees,
double radius,
Rectangle2D dataArea) {
double radians = Math.toRadians(angleDegrees - 90.0);
double minx = dataArea.getMinX() + MARGIN;
double maxx = dataArea.getMaxX() - MARGIN;
double miny = dataArea.getMinY() + MARGIN;
double maxy = dataArea.getMaxY() - MARGIN;
double lengthX = maxx - minx;
double lengthY = maxy - miny;
double length = Math.min(lengthX, lengthY);
double midX = minx + lengthX / 2.0;
double midY = miny + lengthY / 2.0;
double axisMin = this.axis.getLowerBound();
double axisMax = getMaxRadius();
double adjustedRadius = Math.max(radius, axisMin);
double xv = length / 2.0 * Math.cos(radians);
double yv = length / 2.0 * Math.sin(radians);
float x = (float) (midX + (xv * (adjustedRadius - axisMin)
/ (axisMax - axisMin)));
float y = (float) (midY + (yv * (adjustedRadius - axisMin)
/ (axisMax - axisMin)));
int ix = Math.round(x);
int iy = Math.round(y);
Point p = new Point(ix, iy);
return p;
}
/**
* Converts a data value to a coordinate in Java2D space, assuming that the
* axis runs along one edge of the specified dataArea.
* <p>
* Note that it is possible for the coordinate to fall outside the area.
*
* @param value the data value.
* @param area the area for plotting the data.
* @param edge the edge along which the axis lies.
*
* @return The Java2D coordinate.
*/
@Override
public double valueToJava2D(double value, Rectangle2D area,
RectangleEdge edge) {
double result = Double.NaN;
double axisMin = this.first.getFirstMillisecond();
double axisMax = this.last.getLastMillisecond();
if (RectangleEdge.isTopOrBottom(edge)) {
double minX = area.getX();
double maxX = area.getMaxX();
if (isInverted()) {
result = maxX + ((value - axisMin) / (axisMax - axisMin))
* (minX - maxX);
}
else {
result = minX + ((value - axisMin) / (axisMax - axisMin))
* (maxX - minX);
}
}
else if (RectangleEdge.isLeftOrRight(edge)) {
double minY = area.getMinY();
double maxY = area.getMaxY();
if (isInverted()) {
result = minY + (((value - axisMin) / (axisMax - axisMin))
* (maxY - minY));
}
else {
result = maxY - (((value - axisMin) / (axisMax - axisMin))
* (maxY - minY));
}
}
return result;
}
/**
* Converts a coordinate in Java2D space to the corresponding data value,
* assuming that the axis runs along one edge of the specified dataArea.
*
* @param java2DValue the coordinate in Java2D space.
* @param area the area in which the data is plotted.
* @param edge the location.
*
* @return The data value.
*
* @see #valueToJava2D(double, Rectangle2D, RectangleEdge)
*/
@Override
public double java2DToValue(double java2DValue, Rectangle2D area,
RectangleEdge edge) {
Range range = getRange();
double axisMin = range.getLowerBound();
double axisMax = range.getUpperBound();
double min = 0.0;
double max = 0.0;
if (RectangleEdge.isTopOrBottom(edge)) {
min = area.getX();
max = area.getMaxX();
}
else if (RectangleEdge.isLeftOrRight(edge)) {
min = area.getMaxY();
max = area.getY();
}
if (isInverted()) {
return axisMax
- (java2DValue - min) / (max - min) * (axisMax - axisMin);
}
else {
return axisMin
+ (java2DValue - min) / (max - min) * (axisMax - axisMin);
}
}
/**
* Calculates the reserved area.
*
* @param area the area.
* @param edge the edge.
*
* @return The reserved area.
*/
public Rectangle2D reserved(Rectangle2D area, RectangleEdge edge) {
Rectangle2D result = null;
if (edge == RectangleEdge.TOP) {
result = new Rectangle2D.Double(
area.getX(), area.getY(), area.getWidth(), this.top
);
}
else if (edge == RectangleEdge.BOTTOM) {
result = new Rectangle2D.Double(
area.getX(), area.getMaxY() - this.top,
area.getWidth(), this.bottom
);
}
else if (edge == RectangleEdge.LEFT) {
result = new Rectangle2D.Double(
area.getX(), area.getY(), this.left, area.getHeight()
);
}
else if (edge == RectangleEdge.RIGHT) {
result = new Rectangle2D.Double(
area.getMaxX() - this.right, area.getY(),
this.right, area.getHeight()
);
}
return result;
}
/**
* Draws the grid bands for an axis that is aligned to the left or
* right of the data area (that is, a vertical axis).
*
* @param g2 the graphics target (<code>null</code> not permitted).
* @param plotArea the area within which the plot is drawn (not used here).
* @param dataArea the area for the data (to which the axes are aligned,
* <code>null</code> not permitted).
* @param firstGridBandIsDark True: the first grid band takes the
* color of <CODE>gridBandPaint</CODE>.
* False: the second grid band takes the
* color of <CODE>gridBandPaint</CODE>.
* @param ticks a list of ticks (<code>null</code> not permitted).
*/
protected void drawGridBandsVertical(Graphics2D g2, Rectangle2D plotArea,
Rectangle2D dataArea, boolean firstGridBandIsDark,
List ticks) {
boolean currentGridBandIsDark = firstGridBandIsDark;
double xx = dataArea.getX();
double yy1, yy2;
//gets the outline stroke width of the plot
double outlineStrokeWidth = 1.0;
Stroke outlineStroke = getPlot().getOutlineStroke();
if (outlineStroke != null && outlineStroke instanceof BasicStroke) {
outlineStrokeWidth = ((BasicStroke) outlineStroke).getLineWidth();
}
Iterator iterator = ticks.iterator();
ValueTick tick;
Rectangle2D band;
while (iterator.hasNext()) {
tick = (ValueTick) iterator.next();
yy1 = valueToJava2D(tick.getValue() + 0.5d, dataArea,
RectangleEdge.LEFT);
yy2 = valueToJava2D(tick.getValue() - 0.5d, dataArea,
RectangleEdge.LEFT);
if (currentGridBandIsDark) {
g2.setPaint(this.gridBandPaint);
}
else {
g2.setPaint(this.gridBandAlternatePaint);
}
band = new Rectangle2D.Double(xx + outlineStrokeWidth,
Math.min(yy1, yy2), dataArea.getMaxX() - xx
- outlineStrokeWidth, Math.abs(yy2 - yy1));
g2.fill(band);
currentGridBandIsDark = !currentGridBandIsDark;
}
}
/**
* Draws a horizontal line across the chart to represent a 'range marker'.
*
* @param g2 the graphics device.
* @param plot the plot.
* @param rangeAxis the range axis.
* @param marker the marker line.
* @param dataArea the axis data area.
*/
public void drawRangeMarker(Graphics2D g2,
ContourPlot plot,
ValueAxis rangeAxis,
Marker marker,
Rectangle2D dataArea) {
if (marker instanceof ValueMarker) {
ValueMarker vm = (ValueMarker) marker;
double value = vm.getValue();
Range range = rangeAxis.getRange();
if (!range.contains(value)) {
return;
}
double y = rangeAxis.valueToJava2D(value, dataArea,
RectangleEdge.LEFT);
Line2D line = new Line2D.Double(dataArea.getMinX(), y,
dataArea.getMaxX(), y);
Paint paint = marker.getOutlinePaint();
Stroke stroke = marker.getOutlineStroke();
g2.setPaint(paint != null ? paint : Plot.DEFAULT_OUTLINE_PAINT);
g2.setStroke(stroke != null ? stroke : Plot.DEFAULT_OUTLINE_STROKE);
g2.draw(line);
}
}
@Override
public void mouseReleased(MouseEvent e) {
// if we've been panning, we need to reset now that the mouse is
// released...
Rectangle2D zoomRectangle = (Rectangle2D) getChartFieldValueByName("zoomRectangle");
Point2D zoomPoint = (Point2D) getChartFieldValueByName("zoomPoint");
if (getChartFieldValueByName("panLast") != null) {
setChartFieldValue(getChartFieldByName("panLast"), null);
setCursor(Cursor.getDefaultCursor());
} else if (zoomRectangle != null) {
boolean hZoom = false;
boolean vZoom = false;
if ((PlotOrientation) getChartFieldValueByName("orientation") == PlotOrientation.HORIZONTAL) {
hZoom = (Boolean) getChartFieldValueByName("rangeZoomable");
vZoom = (Boolean) getChartFieldValueByName("domainZoomable");
} else {
hZoom = (Boolean) getChartFieldValueByName("domainZoomable");
vZoom = (Boolean) getChartFieldValueByName("rangeZoomable");
}
boolean zoomTrigger1 = hZoom
&& Math.abs(e.getX() - zoomPoint.getX()) >= (Integer) getChartFieldValueByName("zoomTriggerDistance");
boolean zoomTrigger2 = vZoom
&& Math.abs(e.getY() - zoomPoint.getY()) >= (Integer) getChartFieldValueByName("zoomTriggerDistance");
if (zoomTrigger1 || zoomTrigger2) {
if (hZoom && e.getX() < zoomPoint.getX() || vZoom && e.getY() < zoomPoint.getY()) {
restoreAutoBounds();
} else {
double x, y, w, h;
Rectangle2D screenDataArea = getScreenDataArea((int) zoomPoint.getX(), (int) zoomPoint.getY());
double maxX = screenDataArea.getMaxX();
double maxY = screenDataArea.getMaxY();
// for mouseReleased event, (horizontalZoom || verticalZoom)
// will be true, so we can just test for either being false;
// otherwise both are true
if (!vZoom) {
x = zoomPoint.getX();
y = screenDataArea.getMinY();
w = Math.min(zoomRectangle.getWidth(), maxX - zoomPoint.getX());
h = screenDataArea.getHeight();
} else if (!hZoom) {
x = screenDataArea.getMinX();
y = zoomPoint.getY();
w = screenDataArea.getWidth();
h = Math.min(zoomRectangle.getHeight(), maxY - zoomPoint.getY());
} else {
x = zoomPoint.getX();
y = zoomPoint.getY();
w = Math.min(zoomRectangle.getWidth(), maxX - zoomPoint.getX());
h = Math.min(zoomRectangle.getHeight(), maxY - zoomPoint.getY());
}
Rectangle2D zoomArea = new Rectangle2D.Double(x, y, w, h);
zoom(zoomArea);
}
setChartFieldValue(getChartFieldByName("zoomPoint"), null);
setChartFieldValue(getChartFieldByName("zoomRectangle"), null);
} else {
// erase the zoom rectangle
Graphics2D g2 = (Graphics2D) getGraphics();
if ((Boolean) getChartFieldValueByName("useBuffer")) {
repaint();
} else {
drawZoomRectangle(g2, true);
}
g2.dispose();
setChartFieldValue(getChartFieldByName("zoomPoint"), null);
setChartFieldValue(getChartFieldByName("zoomRectangle"), null);
}
}
else if (e.isPopupTrigger()) {
if (getChartFieldValueByName("popup") != null) {
displayPopupMenu(e.getX(), e.getY());
}
}
}
/**
* Draws the needle.
*
* @param g2 the graphics device.
* @param plotArea the plot area.
* @param rotate the rotation point.
* @param angle the angle.
*/
@Override
protected void drawNeedle(Graphics2D g2, Rectangle2D plotArea,
Point2D rotate, double angle) {
GeneralPath shape1 = new GeneralPath();
GeneralPath shape2 = new GeneralPath();
GeneralPath shape3 = new GeneralPath();
float minX = (float) plotArea.getMinX();
float minY = (float) plotArea.getMinY();
float maxX = (float) plotArea.getMaxX();
float maxY = (float) plotArea.getMaxY();
//float midX = (float) (minX + (plotArea.getWidth() * getRotateX()));
//float midY = (float) (minY + (plotArea.getHeight() * getRotateY()));
float midX = (float) (minX + (plotArea.getWidth() * 0.5));
float midY = (float) (minY + (plotArea.getHeight() * 0.8));
float y = maxY - (2 * (maxY - midY));
if (y < minY) {
y = minY;
}
shape1.moveTo(minX, midY);
shape1.lineTo(midX, minY);
shape1.lineTo(midX, y);
shape1.closePath();
shape2.moveTo(maxX, midY);
shape2.lineTo(midX, minY);
shape2.lineTo(midX, y);
shape2.closePath();
shape3.moveTo(minX, midY);
shape3.lineTo(midX, maxY);
shape3.lineTo(maxX, midY);
shape3.lineTo(midX, y);
shape3.closePath();
Shape s1 = shape1;
Shape s2 = shape2;
Shape s3 = shape3;
if ((rotate != null) && (angle != 0)) {
/// we have rotation huston, please spin me
getTransform().setToRotation(angle, rotate.getX(), rotate.getY());
s1 = shape1.createTransformedShape(transform);
s2 = shape2.createTransformedShape(transform);
s3 = shape3.createTransformedShape(transform);
}
if (getHighlightPaint() != null) {
g2.setPaint(getHighlightPaint());
g2.fill(s3);
}
if (getFillPaint() != null) {
g2.setPaint(getFillPaint());
g2.fill(s1);
g2.fill(s2);
}
if (getOutlinePaint() != null) {
g2.setStroke(getOutlineStroke());
g2.setPaint(getOutlinePaint());
g2.draw(s1);
g2.draw(s2);
g2.draw(s3);
}
}
/**
* Clips the specified line to the given rectangle.
*
* @param line the line (<code>null</code> not permitted).
* @param rect the clipping rectangle (<code>null</code> not permitted).
*
* @return <code>true</code> if the clipped line is visible, and
* <code>false</code> otherwise.
*/
public static boolean clipLine(Line2D line, Rectangle2D rect) {
double x1 = line.getX1();
double y1 = line.getY1();
double x2 = line.getX2();
double y2 = line.getY2();
double minX = rect.getMinX();
double maxX = rect.getMaxX();
double minY = rect.getMinY();
double maxY = rect.getMaxY();
int f1 = rect.outcode(x1, y1);
int f2 = rect.outcode(x2, y2);
while ((f1 | f2) != 0) {
if ((f1 & f2) != 0) {
return false;
}
double dx = (x2 - x1);
double dy = (y2 - y1);
// update (x1, y1), (x2, y2) and f1 and f2 using intersections
// then recheck
if (f1 != 0) {
// first point is outside, so we update it against one of the
// four sides then continue
if ((f1 & Rectangle2D.OUT_LEFT) == Rectangle2D.OUT_LEFT
&& dx != 0.0) {
y1 = y1 + (minX - x1) * dy / dx;
x1 = minX;
}
else if ((f1 & Rectangle2D.OUT_RIGHT) == Rectangle2D.OUT_RIGHT
&& dx != 0.0) {
y1 = y1 + (maxX - x1) * dy / dx;
x1 = maxX;
}
else if ((f1 & Rectangle2D.OUT_BOTTOM) == Rectangle2D.OUT_BOTTOM
&& dy != 0.0) {
x1 = x1 + (maxY - y1) * dx / dy;
y1 = maxY;
}
else if ((f1 & Rectangle2D.OUT_TOP) == Rectangle2D.OUT_TOP
&& dy != 0.0) {
x1 = x1 + (minY - y1) * dx / dy;
y1 = minY;
}
f1 = rect.outcode(x1, y1);
}
else if (f2 != 0) {
// second point is outside, so we update it against one of the
// four sides then continue
if ((f2 & Rectangle2D.OUT_LEFT) == Rectangle2D.OUT_LEFT
&& dx != 0.0) {
y2 = y2 + (minX - x2) * dy / dx;
x2 = minX;
}
else if ((f2 & Rectangle2D.OUT_RIGHT) == Rectangle2D.OUT_RIGHT
&& dx != 0.0) {
y2 = y2 + (maxX - x2) * dy / dx;
x2 = maxX;
}
else if ((f2 & Rectangle2D.OUT_BOTTOM) == Rectangle2D.OUT_BOTTOM
&& dy != 0.0) {
x2 = x2 + (maxY - y2) * dx / dy;
y2 = maxY;
}
else if ((f2 & Rectangle2D.OUT_TOP) == Rectangle2D.OUT_TOP
&& dy != 0.0) {
x2 = x2 + (minY - y2) * dx / dy;
y2 = minY;
}
f2 = rect.outcode(x2, y2);
}
}
line.setLine(x1, y1, x2, y2);
return true; // the line is visible - if it wasn't, we'd have
// returned false from within the while loop above
}
/**
* Handles a 'mouse released' event. On Windows, we need to check if this
* is a popup trigger, but only if we haven't already been tracking a zoom
* rectangle.
*
* @param e information about the event.
*/
@Override
public void mouseReleased(MouseEvent e) {
// if we've been panning, we need to reset now that the mouse is
// released...
if (this.panLast != null) {
this.panLast = null;
setCursor(Cursor.getDefaultCursor());
}
else if (this.zoomRectangle != null) {
boolean hZoom, vZoom;
if (this.orientation == PlotOrientation.HORIZONTAL) {
hZoom = this.rangeZoomable;
vZoom = this.domainZoomable;
}
else {
hZoom = this.domainZoomable;
vZoom = this.rangeZoomable;
}
boolean zoomTrigger1 = hZoom && Math.abs(e.getX()
- this.zoomPoint.getX()) >= this.zoomTriggerDistance;
boolean zoomTrigger2 = vZoom && Math.abs(e.getY()
- this.zoomPoint.getY()) >= this.zoomTriggerDistance;
if (zoomTrigger1 || zoomTrigger2) {
if ((hZoom && (e.getX() < this.zoomPoint.getX()))
|| (vZoom && (e.getY() < this.zoomPoint.getY()))) {
restoreAutoBounds();
}
else {
double x, y, w, h;
Rectangle2D screenDataArea = getScreenDataArea(
(int) this.zoomPoint.getX(),
(int) this.zoomPoint.getY());
double maxX = screenDataArea.getMaxX();
double maxY = screenDataArea.getMaxY();
// for mouseReleased event, (horizontalZoom || verticalZoom)
// will be true, so we can just test for either being false;
// otherwise both are true
if (!vZoom) {
x = this.zoomPoint.getX();
y = screenDataArea.getMinY();
w = Math.min(this.zoomRectangle.getWidth(),
maxX - this.zoomPoint.getX());
h = screenDataArea.getHeight();
}
else if (!hZoom) {
x = screenDataArea.getMinX();
y = this.zoomPoint.getY();
w = screenDataArea.getWidth();
h = Math.min(this.zoomRectangle.getHeight(),
maxY - this.zoomPoint.getY());
}
else {
x = this.zoomPoint.getX();
y = this.zoomPoint.getY();
w = Math.min(this.zoomRectangle.getWidth(),
maxX - this.zoomPoint.getX());
h = Math.min(this.zoomRectangle.getHeight(),
maxY - this.zoomPoint.getY());
}
Rectangle2D zoomArea = new Rectangle2D.Double(x, y, w, h);
zoom(zoomArea);
}
this.zoomPoint = null;
this.zoomRectangle = null;
}
else {
// erase the zoom rectangle
Graphics2D g2 = (Graphics2D) getGraphics();
if (this.useBuffer) {
repaint();
}
else {
drawZoomRectangle(g2, true);
}
g2.dispose();
this.zoomPoint = null;
this.zoomRectangle = null;
}
}
else if (e.isPopupTrigger()) {
if (this.popup != null) {
displayPopupMenu(e.getX(), e.getY());
}
}
}
/**
* Zooms in on a selected region.
*
* @param selection the selected region.
*/
public void zoom(Rectangle2D selection) {
// get the origin of the zoom selection in the Java2D space used for
// drawing the chart (that is, before any scaling to fit the panel)
Point2D selectOrigin = translateScreenToJava2D(new Point(
(int) Math.ceil(selection.getX()),
(int) Math.ceil(selection.getY())));
PlotRenderingInfo plotInfo = this.info.getPlotInfo();
Rectangle2D scaledDataArea = getScreenDataArea(
(int) selection.getCenterX(), (int) selection.getCenterY());
if ((selection.getHeight() > 0) && (selection.getWidth() > 0)) {
double hLower = (selection.getMinX() - scaledDataArea.getMinX())
/ scaledDataArea.getWidth();
double hUpper = (selection.getMaxX() - scaledDataArea.getMinX())
/ scaledDataArea.getWidth();
double vLower = (scaledDataArea.getMaxY() - selection.getMaxY())
/ scaledDataArea.getHeight();
double vUpper = (scaledDataArea.getMaxY() - selection.getMinY())
/ scaledDataArea.getHeight();
Plot p = this.chart.getPlot();
if (p instanceof Zoomable) {
// here we tweak the notify flag on the plot so that only
// one notification happens even though we update multiple
// axes...
boolean savedNotify = p.isNotify();
p.setNotify(false);
Zoomable z = (Zoomable) p;
if (z.getOrientation() == PlotOrientation.HORIZONTAL) {
z.zoomDomainAxes(vLower, vUpper, plotInfo, selectOrigin);
z.zoomRangeAxes(hLower, hUpper, plotInfo, selectOrigin);
}
else {
z.zoomDomainAxes(hLower, hUpper, plotInfo, selectOrigin);
z.zoomRangeAxes(vLower, vUpper, plotInfo, selectOrigin);
}
p.setNotify(savedNotify);
}
}
}