313 lines
10 KiB
Java
313 lines
10 KiB
Java
/*
|
|
* Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package sun.awt;
|
|
|
|
import java.awt.Component;
|
|
import java.awt.Graphics;
|
|
import java.awt.Rectangle;
|
|
import java.awt.event.PaintEvent;
|
|
|
|
/**
|
|
* The <code>RepaintArea</code> is a geometric construct created for the
|
|
* purpose of holding the geometry of several coalesced paint events.
|
|
* This geometry is accessed synchronously, although it is written such
|
|
* that painting may still be executed asynchronously.
|
|
*
|
|
* @author Eric Hawkes
|
|
* @since 1.3
|
|
*/
|
|
public class RepaintArea {
|
|
|
|
/**
|
|
* Maximum ratio of bounding rectangle to benefit for which
|
|
* both the vertical and horizontal unions are repainted.
|
|
* For smaller ratios the whole bounding rectangle is repainted.
|
|
* @see #paint
|
|
*/
|
|
private static final int MAX_BENEFIT_RATIO = 4;
|
|
|
|
private static final int HORIZONTAL = 0;
|
|
private static final int VERTICAL = 1;
|
|
private static final int UPDATE = 2;
|
|
|
|
private static final int RECT_COUNT = UPDATE + 1;
|
|
|
|
private Rectangle paintRects[] = new Rectangle[RECT_COUNT];
|
|
|
|
|
|
/**
|
|
* Constructs a new <code>RepaintArea</code>
|
|
* @since 1.3
|
|
*/
|
|
public RepaintArea() {
|
|
}
|
|
|
|
/**
|
|
* Constructs a new <code>RepaintArea</code> initialized to match
|
|
* the values of the specified RepaintArea.
|
|
*
|
|
* @param ra the <code>RepaintArea</code> from which to copy initial
|
|
* values to a newly constructed RepaintArea
|
|
* @since 1.3
|
|
*/
|
|
private RepaintArea(RepaintArea ra) {
|
|
// This constructor is private because it should only be called
|
|
// from the cloneAndReset method
|
|
for (int i = 0; i < RECT_COUNT; i++) {
|
|
paintRects[i] = ra.paintRects[i];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds a <code>Rectangle</code> to this <code>RepaintArea</code>.
|
|
* PAINT Rectangles are divided into mostly vertical and mostly horizontal.
|
|
* Each group is unioned together.
|
|
* UPDATE Rectangles are unioned.
|
|
*
|
|
* @param r the specified <code>Rectangle</code>
|
|
* @param id possible values PaintEvent.UPDATE or PaintEvent.PAINT
|
|
* @since 1.3
|
|
*/
|
|
public synchronized void add(Rectangle r, int id) {
|
|
// Make sure this new rectangle has positive dimensions
|
|
if (r.isEmpty()) {
|
|
return;
|
|
}
|
|
int addTo = UPDATE;
|
|
if (id == PaintEvent.PAINT) {
|
|
addTo = (r.width > r.height) ? HORIZONTAL : VERTICAL;
|
|
}
|
|
if (paintRects[addTo] != null) {
|
|
paintRects[addTo].add(r);
|
|
} else {
|
|
paintRects[addTo] = new Rectangle(r);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Creates a new <code>RepaintArea</code> with the same geometry as this
|
|
* RepaintArea, then removes all of the geometry from this
|
|
* RepaintArea and restores it to an empty RepaintArea.
|
|
*
|
|
* @return ra a new <code>RepaintArea</code> having the same geometry as
|
|
* this RepaintArea.
|
|
* @since 1.3
|
|
*/
|
|
private synchronized RepaintArea cloneAndReset() {
|
|
RepaintArea ra = new RepaintArea(this);
|
|
for (int i = 0; i < RECT_COUNT; i++) {
|
|
paintRects[i] = null;
|
|
}
|
|
return ra;
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
for (int i = 0; i < RECT_COUNT; i++) {
|
|
if (paintRects[i] != null) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Constrains the size of the repaint area to the passed in bounds.
|
|
*/
|
|
public synchronized void constrain(int x, int y, int w, int h) {
|
|
for (int i = 0; i < RECT_COUNT; i++) {
|
|
Rectangle rect = paintRects[i];
|
|
if (rect != null) {
|
|
if (rect.x < x) {
|
|
rect.width -= (x - rect.x);
|
|
rect.x = x;
|
|
}
|
|
if (rect.y < y) {
|
|
rect.height -= (y - rect.y);
|
|
rect.y = y;
|
|
}
|
|
int xDelta = rect.x + rect.width - x - w;
|
|
if (xDelta > 0) {
|
|
rect.width -= xDelta;
|
|
}
|
|
int yDelta = rect.y + rect.height - y - h;
|
|
if (yDelta > 0) {
|
|
rect.height -= yDelta;
|
|
}
|
|
if (rect.width <= 0 || rect.height <= 0) {
|
|
paintRects[i] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Marks the passed in region as not needing to be painted. It's possible
|
|
* this will do nothing.
|
|
*/
|
|
public synchronized void subtract(int x, int y, int w, int h) {
|
|
Rectangle subtract = new Rectangle(x, y, w, h);
|
|
for (int i = 0; i < RECT_COUNT; i++) {
|
|
if (subtract(paintRects[i], subtract)) {
|
|
if (paintRects[i] != null && paintRects[i].isEmpty()) {
|
|
paintRects[i] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invokes paint and update on target Component with optimal
|
|
* rectangular clip region.
|
|
* If PAINT bounding rectangle is less than
|
|
* MAX_BENEFIT_RATIO times the benefit, then the vertical and horizontal unions are
|
|
* painted separately. Otherwise the entire bounding rectangle is painted.
|
|
*
|
|
* @param target Component to <code>paint</code> or <code>update</code>
|
|
* @since 1.4
|
|
*/
|
|
public void paint(Object target, boolean shouldClearRectBeforePaint) {
|
|
Component comp = (Component)target;
|
|
|
|
if (isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
if (!comp.isVisible()) {
|
|
return;
|
|
}
|
|
|
|
RepaintArea ra = this.cloneAndReset();
|
|
|
|
if (!subtract(ra.paintRects[VERTICAL], ra.paintRects[HORIZONTAL])) {
|
|
subtract(ra.paintRects[HORIZONTAL], ra.paintRects[VERTICAL]);
|
|
}
|
|
|
|
if (ra.paintRects[HORIZONTAL] != null && ra.paintRects[VERTICAL] != null) {
|
|
Rectangle paintRect = ra.paintRects[HORIZONTAL].union(ra.paintRects[VERTICAL]);
|
|
int square = paintRect.width * paintRect.height;
|
|
int benefit = square - ra.paintRects[HORIZONTAL].width
|
|
* ra.paintRects[HORIZONTAL].height - ra.paintRects[VERTICAL].width
|
|
* ra.paintRects[VERTICAL].height;
|
|
// if benefit is comparable with bounding box
|
|
if (MAX_BENEFIT_RATIO * benefit < square) {
|
|
ra.paintRects[HORIZONTAL] = paintRect;
|
|
ra.paintRects[VERTICAL] = null;
|
|
}
|
|
}
|
|
for (int i = 0; i < paintRects.length; i++) {
|
|
if (ra.paintRects[i] != null
|
|
&& !ra.paintRects[i].isEmpty())
|
|
{
|
|
// Should use separate Graphics for each paint() call,
|
|
// since paint() can change Graphics state for next call.
|
|
Graphics g = comp.getGraphics();
|
|
if (g != null) {
|
|
try {
|
|
g.setClip(ra.paintRects[i]);
|
|
if (i == UPDATE) {
|
|
updateComponent(comp, g);
|
|
} else {
|
|
if (shouldClearRectBeforePaint) {
|
|
g.clearRect( ra.paintRects[i].x,
|
|
ra.paintRects[i].y,
|
|
ra.paintRects[i].width,
|
|
ra.paintRects[i].height);
|
|
}
|
|
paintComponent(comp, g);
|
|
}
|
|
} finally {
|
|
g.dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls <code>Component.update(Graphics)</code> with given Graphics.
|
|
*/
|
|
protected void updateComponent(Component comp, Graphics g) {
|
|
if (comp != null) {
|
|
comp.update(g);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls <code>Component.paint(Graphics)</code> with given Graphics.
|
|
*/
|
|
protected void paintComponent(Component comp, Graphics g) {
|
|
if (comp != null) {
|
|
comp.paint(g);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Subtracts subtr from rect. If the result is rectangle
|
|
* changes rect and returns true. Otherwise false.
|
|
*/
|
|
static boolean subtract(Rectangle rect, Rectangle subtr) {
|
|
if (rect == null || subtr == null) {
|
|
return true;
|
|
}
|
|
Rectangle common = rect.intersection(subtr);
|
|
if (common.isEmpty()) {
|
|
return true;
|
|
}
|
|
if (rect.x == common.x && rect.y == common.y) {
|
|
if (rect.width == common.width) {
|
|
rect.y += common.height;
|
|
rect.height -= common.height;
|
|
return true;
|
|
} else
|
|
if (rect.height == common.height) {
|
|
rect.x += common.width;
|
|
rect.width -= common.width;
|
|
return true;
|
|
}
|
|
} else
|
|
if (rect.x + rect.width == common.x + common.width
|
|
&& rect.y + rect.height == common.y + common.height)
|
|
{
|
|
if (rect.width == common.width) {
|
|
rect.height -= common.height;
|
|
return true;
|
|
} else
|
|
if (rect.height == common.height) {
|
|
rect.width -= common.width;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public String toString() {
|
|
return super.toString() + "[ horizontal=" + paintRects[0] +
|
|
" vertical=" + paintRects[1] +
|
|
" update=" + paintRects[2] + "]";
|
|
}
|
|
}
|