/**
* 获得图片的矩形大小
*
* @return
*/
private Rectangle getCanvasDimension(JpdlModel jpdlModel) {
Rectangle rectangle = new Rectangle();
Rectangle rect;
for (Node node : jpdlModel.getNodes().values()) {
rect = node.getRectangle();
if (rect.getMaxX() > rectangle.getMaxX()) {
rectangle.width = (int) rect.getMaxX();
}
if (rect.getMaxY() > rectangle.getMaxY()) {
rectangle.height = (int) rect.getMaxY();
}
for (Transition transition : node.getTransitions()) {
List<Point> trace = transition.getLineTrace();
for (Point point : trace) {
if (rectangle.getMaxX() < point.x) {
rectangle.width = point.x;
}
if (rectangle.getMaxY() < point.y) {
rectangle.height = point.y;
}
}
}
}
rectangle.width += 60;
rectangle.height += 20;
return rectangle;
}
protected Rectangle checkBounds(Rectangle source, Rectangle target) {
if (target.contains(source)) return new Rectangle(target);
else {
Rectangle trimmedSource = new Rectangle(source);
// is source outter target left
if (trimmedSource.x < target.x) {
trimmedSource.x = target.x;
if (trimmedSource.width > target.width) trimmedSource.width = target.width;
}
// is source outter target top
if (trimmedSource.y < target.y) {
trimmedSource.y = target.y;
if (trimmedSource.height > target.height) trimmedSource.height = target.height;
}
// is source outter target right
if (trimmedSource.getMaxX() > target.getMaxX()) {
trimmedSource.x = (int) target.getMaxX() - trimmedSource.width;
// if (trimmedSource.width > target.width)
// trimmedSource.width = target.width;
}
// is source outter target bottom
if (trimmedSource.getMaxY() > target.getMaxY()) {
trimmedSource.y = (int) target.getMaxY() - trimmedSource.height;
// if (trimmedSource.height > target.height)
// trimmedSource.height = target.height;
}
return trimmedSource;
}
}
/**
* Creates the map's bounding box in real world coordinates.
*
* @param worldToScreen a transform which converts World coordinates to screen pixel coordinates.
* No assumptions are done on axis order as this is assumed to be pre-calculated. The affine
* transform may specify an rotation, in case the envelope will encompass the complete
* (rotated) world polygon.
* @param paintArea the size of the rendering output area
* @return the envelope in world coordinates corresponding to the screen rectangle.
*/
public static Envelope createMapEnvelope(Rectangle paintArea, AffineTransform worldToScreen)
throws NoninvertibleTransformException {
//
// (X1,Y1) (X2,Y1)
//
// (X1,Y2) (X2,Y2)
double[] pts = new double[8];
pts[0] = paintArea.getMinX();
pts[1] = paintArea.getMinY();
pts[2] = paintArea.getMaxX();
pts[3] = paintArea.getMinY();
pts[4] = paintArea.getMaxX();
pts[5] = paintArea.getMaxY();
pts[6] = paintArea.getMinX();
pts[7] = paintArea.getMaxY();
worldToScreen.inverseTransform(pts, 0, pts, 0, 4);
double xMin = Double.MAX_VALUE;
double yMin = Double.MAX_VALUE;
double xMax = -Double.MAX_VALUE;
double yMax = -Double.MAX_VALUE;
for (int i = 0; i < 4; i++) {
xMin = Math.min(xMin, pts[2 * i]);
yMin = Math.min(yMin, pts[2 * i + 1]);
xMax = Math.max(xMax, pts[2 * i]);
yMax = Math.max(yMax, pts[2 * i + 1]);
}
return new Envelope(xMin, xMax, yMin, yMax);
}
// Draws a line that connects the building to each other
private void drawLine(Graphics2D g2, Rectangle r1, Rectangle r2, String type) {
int x1 = (int) r1.getCenterX();
int y1 = (int) r1.getCenterY();
int x2 = (int) r2.getCenterX();
int y2 = (int) r2.getCenterY();
if (type.equals("DownToUp")) {
g2.drawLine(x1, r1.y + r1.height, r2.x, y2);
} else if (type.equals("UpToDown")) {
g2.drawLine((int) r1.getMaxX(), y1, x2, (int) r2.getMaxY());
} else if (type.equals("SideToSide")) {
g2.drawLine((int) r1.getMaxX(), y1 + 20, r2.x, y2 + 20);
}
}
/**
* Clears the area of the tile on the graphics
*
* @param graphics graphics to draw onto
* @param style raster symbolizer
* @throws FactoryException
* @throws TransformException
* @throws RenderException
*/
private void renderBlankTile(Graphics2D graphics, WMTTile tile, WMTRenderJob renderJob)
throws Exception {
if (tile == null) {
return;
}
// get the bounds of the tile and convert to necessary viewport projection
Envelope bnds = renderJob.projectTileToMapCrs(tile.getExtent());
// determine screen coordinates of tiles
Point upperLeft = getContext().worldToPixel(new Coordinate(bnds.getMinX(), bnds.getMinY()));
Point bottomRight = getContext().worldToPixel(new Coordinate(bnds.getMaxX(), bnds.getMaxY()));
Rectangle tileSize = new Rectangle(upperLeft);
tileSize.add(bottomRight);
// render
try {
graphics.setBackground(new Color(255, 255, 255, 0)); // set the tile transparent for now
graphics.clearRect(tileSize.x, tileSize.y, tileSize.width, tileSize.height);
if (TESTING) {
/* for testing draw border around tiles */
graphics.setColor(Color.BLACK);
graphics.drawLine(
(int) tileSize.getMinX(),
(int) tileSize.getMinY(),
(int) tileSize.getMinX(),
(int) tileSize.getMaxY());
graphics.drawLine(
(int) tileSize.getMinX(),
(int) tileSize.getMinY(),
(int) tileSize.getMaxX(),
(int) tileSize.getMinY());
graphics.drawLine(
(int) tileSize.getMaxX(),
(int) tileSize.getMinY(),
(int) tileSize.getMaxX(),
(int) tileSize.getMaxY());
graphics.drawLine(
(int) tileSize.getMinX(),
(int) tileSize.getMaxY(),
(int) tileSize.getMaxX(),
(int) tileSize.getMaxY());
}
} catch (Throwable t) {
WMTPlugin.log("Error Rendering Blank tile. Painting Tile: " + tile.getId(), t); // $NON-NLS-1$
}
}
public void paint(Graphics2D g, ChartFrame cf, Rectangle bounds) {
Dataset ls = visibleDataset(cf, LS);
if (ls != null) {
Range range = cf.getSplitPanel().getChartPanel().getRange();
g.setColor(properties.getColor());
g.setStroke(properties.getStroke());
double y = cf.getChartData().getY(range.getLowerBound(), bounds, range, false);
g.draw(new Line2D.Double(bounds.getMinX(), y, bounds.getMaxX(), y));
for (int i = 0; i < ls.getItemsCount(); i++) {
if (ls.getDataItem(i) != null) {
double x = cf.getChartData().getX(i, bounds);
double y1 = cf.getChartData().getY(range.getLowerBound(), bounds, range, false);
double y2 = cf.getChartData().getY(range.getUpperBound(), bounds, range, false);
double w = cf.getChartProperties().getBarWidth();
g.draw(new Line2D.Double(x - w / 2, y1, x, y2));
g.draw(new Line2D.Double(x + w / 2, y1, x, y2));
}
}
}
}
// Draws the ShopMenu
private void renderShopMenu(Graphics g, Graphics2D g2) {
renderMenuUI(g, g2, "Shop");
// Draws gridpane
int centerX = (int) menuUI.getCenterX();
int maxX = (int) menuUI.getMaxX();
int maxY = (int) menuUI.getMaxY();
int startY = menuUI.y + menuUI.height / 5;
g2.drawLine(centerX, startY, centerX, maxY);
g2.drawLine(menuUI.x, startY, maxX, startY);
// 6*4
for (int i = 0; i < 6; i++) {
for (int k = 0; k < 4; k++) {
g2.drawRect(
menuUI.x + (menuGrid.width * i),
startY + (menuGrid.height * k),
menuGrid.width,
menuGrid.height);
drawItems(
g2,
menuUI.x + (menuGrid.width * i),
startY + (menuGrid.height * k),
menuGrid.width,
menuGrid.height);
}
}
// display cash
g.setFont(fntSmall);
g.drawString("Cash: 1005$", maxX - 2 * menuGrid.width, maxY - menuGrid.height / 3);
}
public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
int cellSize = world.getCellSize();
double scrollPos = 0;
if (orientation == SwingConstants.HORIZONTAL) {
// scrolling left
if (direction < 0) {
scrollPos = visibleRect.getMinX();
}
// scrolling right
else if (direction > 0) {
scrollPos = visibleRect.getMaxX();
}
} else {
// scrolling up
if (direction < 0) {
scrollPos = visibleRect.getMinY();
}
// scrolling down
else if (direction > 0) {
scrollPos = visibleRect.getMaxY();
}
}
int increment = Math.abs((int) Math.IEEEremainder(scrollPos, cellSize));
if (increment == 0) {
increment = cellSize;
}
return increment;
}
protected void checkScale(Rectangle newReal) {
int maxRealX = (int) newReal.getMaxX();
int maxRealY = (int) newReal.getMaxY();
int maxViewX = (int) initViewBounds.getMaxX();
int maxViewY = (int) initViewBounds.getMaxY();
int maxX = Math.max(maxRealX, maxViewX);
int maxY = Math.max(maxRealY, maxViewY);
realBounds = new Rectangle(0, 0, maxX, maxY);
// realBounds = new Rectangle(newReal.x, newReal.y, maxX, maxY);
if (debugBounds) {
logger.debug("viewBounds = " + viewBounds); // $NON-NLS-1$
logger.debug("realBounds = " + realBounds); // $NON-NLS-1$
logger.debug("initViewBounds = " + initViewBounds); // $NON-NLS-1$
}
}
private void adaptDimensions() {
DimensionFloat textSize = Utils.getTextSize(message, notificationFont, frc);
int x = (int) (drawPanelSize.getMaxX() - textSize.getWidth() - 20);
int y = (int) (drawPanelSize.getMinY() + 10);
this.setLocation(x, y);
this.setSize((int) textSize.getWidth() + 10, (int) textSize.getHeight() + 10);
}
@Override
public void refreshContainer() {
if (!this.isMaximum()) {
int height = this.getHeight();
int pos = this.scrollPane.getVerticalScrollBar().getValue();
this.validate();
this.pack();
// this.setMaximumSize(this.getPreferredSize());
Rectangle bounds = this.getBounds();
bounds.height = height;
bounds.width += 32;
int x2 =
(int)
Math.min(
bounds.getMaxX(),
this.getEditorInterface().getDesktopPane().getBounds().getMaxX());
int y2 =
(int)
Math.min(
bounds.getMaxY(),
this.getEditorInterface().getDesktopPane().getBounds().getMaxY());
bounds.setFrameFromDiagonal(bounds.x, bounds.y, x2, y2);
this.setBounds(bounds);
this.scrollPane.getVerticalScrollBar().setValue(pos);
}
}
private static int preferredWidth(JTable table, int col) {
TableColumn tableColumn = table.getColumnModel().getColumn(col);
int width =
(int)
table
.getTableHeader()
.getDefaultRenderer()
.getTableCellRendererComponent(
table, tableColumn.getIdentifier(), false, false, -1, col)
.getPreferredSize()
.getWidth();
if (table.getRowCount() != 0) {
int from = 0, to = 0;
Rectangle rect = table.getVisibleRect();
from = table.rowAtPoint(rect.getLocation());
to = table.rowAtPoint(new Point((int) rect.getMaxX(), (int) rect.getMaxY())) + 1;
for (int row = from; row < to; row++) {
int preferedWidth =
(int)
table
.getCellRenderer(row, col)
.getTableCellRendererComponent(
table, table.getValueAt(row, col), false, false, row, col)
.getPreferredSize()
.getWidth();
width = Math.max(width, preferedWidth);
}
}
return width + table.getIntercellSpacing().width;
}
private Rectangle getLoadedTilesBounds(Rectangle loadedImagePart, Dimension tileSize) {
int x1 = (int) Math.floor(loadedImagePart.getX() / tileSize.getWidth());
int y1 = (int) Math.floor(loadedImagePart.getY() / tileSize.getHeight());
int x2 = (int) Math.ceil((loadedImagePart.getMaxX()) / tileSize.getWidth());
int y2 = (int) Math.ceil((loadedImagePart.getMaxY()) / tileSize.getHeight());
return new Rectangle(x1, y1, x2 - x1, y2 - y1);
}
public Tiling(int tileW, int tileH, Rectangle r) {
int[] size = this.calcMaxTileSize(tileW, tileH, r);
tileMaxWidth = size[0];
tileMaxHeight = size[1];
int stepX, stepY;
int xProv, yProv;
int altoAux, anchoAux;
// Vamos a hacerlo en trozos de AxH
numCols = 1 + (int) (r.width) / tileMaxWidth;
numRows = 1 + (int) (r.height) / tileMaxHeight;
srcPts = new double[numCols * numRows][8];
tile = new Rectangle[numCols * numRows];
yProv = (int) r.y;
for (stepY = 0; stepY < numRows; stepY++) {
if ((yProv + tileMaxHeight) > r.getMaxY()) altoAux = (int) r.getMaxY() - yProv;
else altoAux = tileMaxHeight;
xProv = (int) r.x;
for (stepX = 0; stepX < numCols; stepX++) {
if ((xProv + tileMaxWidth) > r.getMaxX()) anchoAux = (int) r.getMaxX() - xProv;
else anchoAux = tileMaxWidth;
// Rectangle newRect = new Rectangle(xProv, yProv, anchoAux,
// altoAux);
int tileCnt = stepY * numCols + stepX;
// Parte que dibuja
srcPts[tileCnt][0] = xProv;
srcPts[tileCnt][1] = yProv;
srcPts[tileCnt][2] = xProv + anchoAux + 1;
srcPts[tileCnt][3] = yProv;
srcPts[tileCnt][4] = xProv + anchoAux + 1;
srcPts[tileCnt][5] = yProv + altoAux + 1;
srcPts[tileCnt][6] = xProv;
srcPts[tileCnt][7] = yProv + altoAux + 1;
tile[tileCnt] = new Rectangle(xProv, yProv, anchoAux + 1, altoAux + 1);
xProv += tileMaxWidth;
}
yProv += tileMaxHeight;
}
}
@Override
public void mouseMoved(MouseEvent e) {
if (this.selecting) {
this.disable();
if (e.getX() > selected.getMaxX() - 5
&& e.getX() < selected.getMaxX() + 5
&& e.getY() > selected.getMaxY() - 5
&& e.getY() < selected.getMaxY() + 5) {
e.getComponent().setCursor(new Cursor(Cursor.SE_RESIZE_CURSOR));
curDir = DIR_SE;
} else if (e.getX() == selected.getMinX()
&& (e.getY() < selected.getMaxY() && e.getY() > selected.getMinY())) {
e.getComponent().setCursor(new Cursor(Cursor.W_RESIZE_CURSOR));
curDir = DIR_W;
} else if (e.getX() == selected.getMaxX()
&& (e.getY() < selected.getMaxY() && e.getY() > selected.getMinY())) {
e.getComponent().setCursor(new Cursor(Cursor.E_RESIZE_CURSOR));
curDir = DIR_E;
} else if (e.getY() < selected.getMaxY() + 5
&& e.getY() > selected.getMaxY() - 5
&& (e.getX() < selected.getMaxX() && e.getX() > selected.getMinX())) {
e.getComponent().setCursor(new Cursor(Cursor.S_RESIZE_CURSOR));
curDir = DIR_S;
} else if (e.getY() == selected.getMinY()
&& (e.getX() < selected.getMaxX() && e.getX() > selected.getMinX())) {
curDir = DIR_N;
e.getComponent().setCursor(new Cursor(Cursor.N_RESIZE_CURSOR));
} else if (e.getY() < selected.getCenterY() + 10
&& e.getY() > selected.getCenterY() - 10
&& (e.getX() < (selected.getCenterX() + 10) && e.getX() > selected.getCenterX() - 10)) {
e.getComponent().setCursor(new Cursor(Cursor.MOVE_CURSOR));
this.enable();
curDir = NOP;
} else {
e.getComponent().setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
curDir = NOP;
}
} else {
e.getComponent().setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
curDir = NOP;
}
}
/**
* Constructor creates an instance to be used for fill operations.
*
* @param shading the shading type to be used
* @param colorModel the color model to be used
* @param xform transformation for user to device space
* @param matrix the pattern matrix concatenated with that of the parent content stream
* @param deviceBounds the bounds of the area to paint, in device units
* @throws IOException if there is an error getting the color space or doing color conversion.
*/
public AxialShadingContext(
PDShadingType2 shading,
ColorModel colorModel,
AffineTransform xform,
Matrix matrix,
Rectangle deviceBounds)
throws IOException {
super(shading, colorModel, xform, matrix);
this.axialShadingType = shading;
coords = shading.getCoords().toFloatArray();
// domain values
if (shading.getDomain() != null) {
domain = shading.getDomain().toFloatArray();
} else {
// set default values
domain = new float[] {0, 1};
}
// extend values
COSArray extendValues = shading.getExtend();
if (shading.getExtend() != null) {
extend = new boolean[2];
extend[0] = ((COSBoolean) extendValues.get(0)).getValue();
extend[1] = ((COSBoolean) extendValues.get(1)).getValue();
} else {
// set default values
extend = new boolean[] {false, false};
}
// calculate some constants to be used in getRaster
x1x0 = coords[2] - coords[0];
y1y0 = coords[3] - coords[1];
d1d0 = domain[1] - domain[0];
denom = Math.pow(x1x0, 2) + Math.pow(y1y0, 2);
try {
// get inverse transform to be independent of current user / device space
// when handling actual pixels in getRaster()
rat = matrix.createAffineTransform().createInverse();
rat.concatenate(xform.createInverse());
} catch (NoninvertibleTransformException ex) {
LOG.error(ex, ex);
}
// shading space -> device space
AffineTransform shadingToDevice = (AffineTransform) xform.clone();
shadingToDevice.concatenate(matrix.createAffineTransform());
// worst case for the number of steps is opposite diagonal corners, so use that
double dist =
Math.sqrt(
Math.pow(deviceBounds.getMaxX() - deviceBounds.getMinX(), 2)
+ Math.pow(deviceBounds.getMaxY() - deviceBounds.getMinY(), 2));
factor = (int) Math.ceil(dist);
// build the color table for the given number of steps
colorTable = calcColorTable();
}
/**
* Moves the current location by a given amount.
*
* @param dr the number of rows by which to move the location
* @param dc the number of columns by which to move the location
*/
public void moveLocation(int dr, int dc) {
Location newLocation =
new Location(currentLocation.getRow() + dr, currentLocation.getCol() + dc);
if (!grid.isValid(newLocation)) return;
currentLocation = newLocation;
JViewport viewPort = getEnclosingViewport();
if (isPannableUnbounded()) {
if (originRow > currentLocation.getRow()) originRow = currentLocation.getRow();
if (originCol > currentLocation.getCol()) originCol = currentLocation.getCol();
Dimension dim = viewPort.getSize();
int rows = dim.height / (cellSize + 1);
int cols = dim.width / (cellSize + 1);
if (originRow + rows - 1 < currentLocation.getRow())
originRow = currentLocation.getRow() - rows + 1;
if (originCol + rows - 1 < currentLocation.getCol())
originCol = currentLocation.getCol() - cols + 1;
} else if (viewPort != null) {
int dx = 0;
int dy = 0;
Point p = pointForLocation(currentLocation);
Rectangle locRect =
new Rectangle(p.x - cellSize / 2, p.y - cellSize / 2, cellSize + 1, cellSize + 1);
Rectangle viewRect = viewPort.getViewRect();
if (!viewRect.contains(locRect)) {
while (locRect.x < viewRect.x + dx) dx -= cellSize + 1;
while (locRect.y < viewRect.y + dy) dy -= cellSize + 1;
while (locRect.getMaxX() > viewRect.getMaxX() + dx) dx += cellSize + 1;
while (locRect.getMaxY() > viewRect.getMaxY() + dy) dy += cellSize + 1;
Point pt = viewPort.getViewPosition();
pt.x += dx;
pt.y += dy;
viewPort.setViewPosition(pt);
}
}
repaint();
showTip(getToolTipText(currentLocation), pointForLocation(currentLocation));
}
private Point2D.Double checkInBounds(double newX, double newY) {
if (!bounds.contains(newX, newY)) {
if (bounds.getMinX() > newX) {
newX = bounds.getMinX();
newY = adjustBunnyWhenHit(180, newX, newY).getY();
} else if (bounds.getMaxX() < newX) {
newX = bounds.getMaxX();
newY = adjustBunnyWhenHit(0, newX, newY).getY();
}
if (bounds.getMinY() > newY) {
newY = bounds.getMinY();
newX = adjustBunnyWhenHit(270, newX, newY).getX();
} else if (bounds.getMaxY() < newY) {
newY = bounds.getMaxY();
newX = adjustBunnyWhenHit(90, newX, newY).getX();
}
orientation = fixOrientation(tempOrientation);
}
return (new Point2D.Double(newX, newY));
}
public static Point getLocationForCaret(JTextComponent pathTextField) {
Point point;
int position = pathTextField.getCaretPosition();
try {
final Rectangle rec = pathTextField.modelToView(position);
point = new Point((int) rec.getMaxX(), (int) rec.getMaxY());
} catch (BadLocationException e) {
point = pathTextField.getCaret().getMagicCaretPosition();
}
SwingUtilities.convertPointToScreen(point, pathTextField);
point.y += 2;
return point;
}
private Rectangle getPrefetchingRegion(
Rectangle loadedTilesBounds, BufferedVirtualSlideImage image, int resIndex) {
Dimension tileSize = image.getTileSize(resIndex);
Dimension tilePrefetchingRadius = getPrefetchingRadiusInTiles(tileSize);
int tileColumns =
(int) Math.ceil(image.getImageSize(resIndex).getWidth() / tileSize.getWidth());
int tileRows = (int) Math.ceil(image.getImageSize(resIndex).getHeight() / tileSize.getHeight());
int x1 = (int) Math.max(loadedTilesBounds.getX() - tilePrefetchingRadius.getWidth(), 0);
int y1 = (int) Math.max(loadedTilesBounds.getY() - tilePrefetchingRadius.getHeight(), 0);
int x2 =
(int) Math.min(loadedTilesBounds.getMaxX() + tilePrefetchingRadius.getWidth(), tileColumns);
int y2 =
(int) Math.min(loadedTilesBounds.getMaxY() + tilePrefetchingRadius.getHeight(), tileRows);
return new Rectangle(x1, y1, x2 - x1, y2 - y1);
}
// Draws the CharacterOverview
private void renderCharMenu(Graphics g, Graphics2D g2) {
renderMenuUI(g, g2, "Character");
// Draws gridpane
int maxX = (int) menuUI.getMaxX();
int maxY = (int) menuUI.getMaxY();
int startY = menuUI.y + menuUI.height / 5;
g2.drawLine(menuUI.x, startY, maxX, startY);
g2.drawRect(menuUI.x + menuGrid.width, startY, 4 * menuGrid.width, 4 * menuGrid.height);
// 2*4
for (int i = 0; i < 2; i++) {
for (int k = 0; k < 4; k++) {
g2.drawRect(
menuUI.x + ((menuUI.width - menuGrid.width) * i),
startY + (menuGrid.height * k),
menuGrid.width,
menuGrid.height);
drawItems(
g2,
menuUI.x + ((menuUI.width - menuGrid.width)),
startY + (menuGrid.height),
menuGrid.width,
menuGrid.height);
}
}
// draws the character inside the big middle grid
movingCharRight.renderAnimation(
g,
menuUI.x + 2 * menuGrid.width,
startY + menuGrid.height,
2 * menuGrid.width,
2 * menuGrid.height);
// charactar stats
g.setFont(fntSmall);
g.drawString("HP: 100/100", menuUI.x + menuGrid.width, maxY - menuGrid.height / 2);
g.drawString("STR: 100", menuUI.x + menuGrid.width, maxY - menuGrid.height / 4);
g.drawString("Lvl: 5", (int) menuUI.getCenterX() + menuGrid.width, maxY - menuGrid.height / 2);
g.drawString(
"XP: 7/100", (int) menuUI.getCenterX() + menuGrid.width, maxY - menuGrid.height / 4);
}
/**
* Compute the bounding screen extent of a rotated rectangle.
*
* @param rect Rectangle to rotate.
* @param x X coordinate of the rotation point.
* @param y Y coordinate of the rotation point.
* @param rotation Rotation angle.
* @return The smallest rectangle that completely contains {@code rect} when rotated by the
* specified angle.
*/
protected Rectangle computeRotatedScreenExtent(Rectangle rect, int x, int y, Angle rotation) {
Rectangle r = new Rectangle(rect);
// Translate the rectangle to the rotation point.
r.translate(-x, -y);
// Compute corner points
Vec4[] corners = {
new Vec4(r.getMaxX(), r.getMaxY()),
new Vec4(r.getMaxX(), r.getMinY()),
new Vec4(r.getMinX(), r.getMaxY()),
new Vec4(r.getMinX(), r.getMinY())
};
// Rotate the rectangle
Matrix rotationMatrix = Matrix.fromRotationZ(rotation);
for (int i = 0; i < corners.length; i++) {
corners[i] = corners[i].transformBy3(rotationMatrix);
}
// Find the bounding rectangle of rotated points.
int minX = Integer.MAX_VALUE;
int minY = Integer.MAX_VALUE;
int maxX = -Integer.MAX_VALUE;
int maxY = -Integer.MAX_VALUE;
for (Vec4 v : corners) {
if (v.x > maxX) maxX = (int) v.x;
if (v.x < minX) minX = (int) v.x;
if (v.y > maxY) maxY = (int) v.y;
if (v.y < minY) minY = (int) v.y;
}
// Set bounds and translate the rectangle back to where it started.
r.setBounds(minX, minY, maxX - minX, maxY - minY);
r.translate(x, y);
return r;
}
@Override
public List<Tile> getTilesToPrefetch(
BufferedVirtualSlideImage image, Rectangle loadedImagePart, ImageIndex imageIndex) {
Rectangle loadedTiles =
getLoadedTilesBounds(loadedImagePart, image.getTileSize(imageIndex.getResolutionIndex()));
Rectangle prefetchingRegion =
getPrefetchingRegion(loadedTiles, image, imageIndex.getResolutionIndex());
List<Tile> tilesToPrefetch = new ArrayList<Tile>();
for (int y = prefetchingRegion.y; y < prefetchingRegion.getMaxY(); y++) {
for (int x = prefetchingRegion.x; x < prefetchingRegion.getMaxX(); x++) {
if (!loadedTiles.contains(x, y)) {
tilesToPrefetch.add(new Tile(x, y, imageIndex));
}
}
}
return tilesToPrefetch;
}
public void mouseDragged(MouseEvent e) {
Rectangle r = container.getViewport().getViewRect();
final int stepSize = 10;
int newx = (int) r.getMinX();
int newy = (int) r.getMinY();
// scroll when dragging out of view
if (e.getX() > r.getMaxX()) {
newx += stepSize;
}
if (e.getX() < r.getMinX()) {
newx = Math.max(newx - stepSize, 0);
}
if (e.getY() > r.getMaxY()) {
newy += stepSize;
}
if (e.getY() < r.getMinY()) {
newy = Math.max(newy - stepSize, 0);
}
scrollTo(newx, newy);
child.mouseMove(new SwingMouseEvent(e));
}
/**
* Returns true if the specified region is visible in the specified {@link Graphics} object.<br>
* Internally use the {@link Graphics} clip area to determine if region is visible.
*/
public static boolean isVisible(Graphics g, Rectangle region) {
if ((g == null) || (region == null)) return false;
final Rectangle clipRegion = g.getClipBounds();
// no clip region --> return true
if (clipRegion == null) return true;
if (region.width == 0) {
// special case of single point region
if (region.height == 0) return clipRegion.contains(region.x, region.y);
else
// special case of null width region
return clipRegion.contains(region.x, region.getMinY())
|| clipRegion.contains(region.x, region.getMaxY());
} else if (region.height == 0)
// special case of null height region
return clipRegion.contains(region.getMinX(), region.y)
|| clipRegion.contains(region.getMaxX(), region.y);
else return clipRegion.intersects(region);
}
public void drawCollapsedMarker(int x, int y, int width, int height) {
// rectangle
int rectangleWidth = MARKER_WIDTH;
int rectangleHeight = MARKER_WIDTH;
Rectangle rect =
new Rectangle(
x + (width - rectangleWidth) / 2,
y + height - rectangleHeight - 3,
rectangleWidth,
rectangleHeight);
g.draw(rect);
// plus inside rectangle
Line2D.Double line =
new Line2D.Double(
rect.getCenterX(), rect.getY() + 2, rect.getCenterX(), rect.getMaxY() - 2);
g.draw(line);
line =
new Line2D.Double(
rect.getMinX() + 2, rect.getCenterY(), rect.getMaxX() - 2, rect.getCenterY());
g.draw(line);
}
public static void renderCards(
GameScreen screen,
Graphics2D g,
Iterable<Card> cards,
Rectangle2D loc,
Map<Card, Rectangle> cardLocations) {
Shape clip = g.getClip();
int x = 0;
int col = 0;
int row = 0;
for (Card card : cards) {
Rectangle r = getCardBounds(x, row, loc.getWidth(), loc.getHeight());
if (x > 0 && r.getMaxX() > loc.getWidth() && col > 0) {
x = 0;
row++;
r = getCardBounds(x, row, loc.getWidth(), loc.getHeight());
}
r.translate((int) loc.getX(), (int) loc.getY());
cardLocations.put(card, r);
BufferedImage bi = ClientCache.getCardImage(card.detailsID);
if (clip.intersects(r) && card != screen.getPickedUpCard()) {
CardRenderer.draw(card, bi, r, g);
}
if (screen.debug) {
g.setColor(Color.white);
g.setFont(new Font("Arial", Font.BOLD, 19));
ClientUtils.drawCenteredString(g, r, card.id + "");
}
x += r.width + 10;
col++;
}
}
/**
* Creates a master shape of the letter.
*
* @param shape
* @return the master shape
*/
private final Master createMaster(RenderContext ctx, Shape shape, double ascent) {
final Area area = new Area(shape);
final double scale = MASTER_HEIGHT / ascent;
area.transform(AffineTransform.getScaleInstance(scale, scale));
final Rectangle bounds = area.getBounds();
// System.out.println("createMaster bounds " + bounds);
// area.transform(AffineTransform.getTranslateInstance(-bounds.getMinX(),
// -bounds.getMinY()));
// bounds = area.getBounds();
final int minX = (int) (bounds.getMinX() - 0.5);
final int maxX = (int) (bounds.getMaxX() + 0.5);
final int minY = (int) (bounds.getMinY() - 0.5);
final int maxY = (int) (bounds.getMaxY() + 0.5);
final int width = maxX - minX;
final int height = maxY - minY;
BitSet bits = (BitSet) ctx.getObject(BITS_NAME);
if (bits == null) {
bits = new BitSet(width * height);
ctx.setObject(BITS_NAME, bits);
} else {
bits.clear();
}
int ofs = 0;
for (int y = maxY; y > minY; y--) {
for (int x = minX; x < maxX; x++) {
if (area.contains(x, y)) {
bits.set(ofs);
}
ofs++;
}
}
return new Master(bits, width, height, minX, minY);
}
@Override
public void mouseDragged(MouseEvent e) {
if (this.selecting) {
int to;
this.dragging = true;
switch (curDir) {
case DIR_E:
to = (int) (e.getX() - this.selected.getMaxX());
if ((this.selected.width + to) > 0) {
this.selected.width += to;
this.gui.getSelected().getNiftyElement().setWidth(selected.width);
this.gui.getSelected().addAttribute("width", "" + selected.width + "px");
}
break;
case DIR_W:
to = (int) (this.selected.getMinX() - e.getX());
if ((this.selected.width + to) > 0) {
this.selected.x = e.getX();
this.selected.width += to;
this.gui.getSelected().addAttribute("width", "" + selected.width + "px");
if (this.gui.getSelected().getParent().getAttribute("childLayout").equals("absolute")) {
int x = gui.getSelected().getParent().getNiftyElement().getX();
this.gui.getSelected().addAttribute("x", "" + (e.getX() - x) + "px");
}
}
break;
case DIR_S:
to = (int) (e.getY() - this.selected.getMaxY());
if ((this.selected.height + to) > 0) {
this.selected.height += to;
this.gui.getSelected().getNiftyElement().setHeight(selected.height);
this.gui.getSelected().addAttribute("height", "" + selected.height + "px");
}
break;
case DIR_SE:
to = (int) (e.getX() - this.selected.getMaxX());
int toy = (int) (e.getY() - this.selected.getMaxY());
if (((this.selected.width + to) > 0) && (this.selected.height + to) > 0) {
if (e.isControlDown()) this.selected.height += to;
else this.selected.height += toy;
this.gui.getSelected().getNiftyElement().setHeight(selected.height);
this.gui.getSelected().addAttribute("height", "" + selected.height + "px");
this.selected.width += to;
this.gui.getSelected().getNiftyElement().setWidth(selected.width);
this.gui.getSelected().addAttribute("width", "" + selected.width + "px");
if (e.isControlDown()) {
Point gtry = new Point((int) selected.getMaxX(), (int) selected.getMaxY());
// SwingUtilities.convertPointToScreen(gtry, this);
// mouseBot.mouseMove(gtry.x,gtry.y);
}
}
break;
case DIR_N:
to = (int) (this.selected.getMinY() - e.getY());
if ((this.selected.height + to) > 0) {
this.selected.height += to;
this.selected.y = e.getY();
this.gui.getSelected().addAttribute("height", "" + selected.height + "px");
if (this.gui.getSelected().getParent().getAttribute("childLayout").equals("absolute")) {
int y = gui.getSelected().getParent().getNiftyElement().getY();
this.gui.getSelected().addAttribute("y", "" + (e.getY() - y) + "px");
}
}
break;
default:
dragging = false;
}
v.displayRect(selected.x, selected.y, selected.height, selected.width);
}
}
/*
* (non-Javadoc)
*
* @see org.jvnet.flamingo.ribbon.ui.BasicRibbonUI#paintTaskArea(java.awt.
* Graphics , int, int, int, int)
*/
@Override
protected void paintTaskArea(Graphics g, int x, int y, int width, int height) {
if (this.ribbon.getTaskCount() == 0) return;
Graphics2D g2d = (Graphics2D) g.create();
RibbonTask selectedTask = this.ribbon.getSelectedTask();
JRibbonTaskToggleButton selectedTaskButton = this.taskToggleButtons.get(selectedTask);
Rectangle selectedTaskButtonBounds = selectedTaskButton.getBounds();
Point converted =
SwingUtilities.convertPoint(
selectedTaskButton.getParent(), selectedTaskButtonBounds.getLocation(), this.ribbon);
float radius =
SubstanceSizeUtils.getClassicButtonCornerRadius(
SubstanceSizeUtils.getComponentFontSize(this.ribbon));
float borderDelta = SubstanceSizeUtils.getBorderStrokeWidth() / 2.0f;
SubstanceBorderPainter borderPainter = SubstanceCoreUtilities.getBorderPainter(this.ribbon);
float borderThickness = SubstanceSizeUtils.getBorderStrokeWidth();
AbstractRibbonBand band = (selectedTask.getBandCount() == 0) ? null : selectedTask.getBand(0);
SubstanceColorScheme borderScheme =
SubstanceColorSchemeUtilities.getColorScheme(
band, ColorSchemeAssociationKind.BORDER, ComponentState.ENABLED);
Rectangle taskToggleButtonsViewportBounds =
taskToggleButtonsScrollablePanel.getView().getParent().getBounds();
taskToggleButtonsViewportBounds.setLocation(
SwingUtilities.convertPoint(
taskToggleButtonsScrollablePanel,
taskToggleButtonsViewportBounds.getLocation(),
this.ribbon));
int startSelectedX = Math.max(converted.x + 1, (int) taskToggleButtonsViewportBounds.getMinX());
startSelectedX = Math.min(startSelectedX, (int) taskToggleButtonsViewportBounds.getMaxX());
int endSelectedX =
Math.min(
converted.x + selectedTaskButtonBounds.width - 1,
(int) taskToggleButtonsViewportBounds.getMaxX());
endSelectedX = Math.max(endSelectedX, (int) taskToggleButtonsViewportBounds.getMinX());
Shape outerContour =
RibbonBorderShaper.getRibbonBorderOutline(
this.ribbon,
x + borderDelta,
x + width - borderDelta,
startSelectedX - borderThickness,
endSelectedX + borderThickness,
converted.y + borderDelta,
y + borderDelta,
y + height - borderDelta,
radius);
Shape innerContour =
RibbonBorderShaper.getRibbonBorderOutline(
this.ribbon,
x + borderDelta + borderThickness,
x + width - borderThickness - borderDelta,
startSelectedX - borderThickness,
endSelectedX + borderThickness,
converted.y + borderDelta + borderThickness,
y + borderDelta + borderThickness,
y + height - borderThickness - borderDelta,
radius);
g2d.setColor(
SubstanceColorSchemeUtilities.getColorScheme(band, ComponentState.ENABLED)
.getBackgroundFillColor());
g2d.clipRect(x, y, width, height + 2);
g2d.fill(outerContour);
// g2d.setColor(Color.red);
// g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
// RenderingHints.VALUE_ANTIALIAS_ON);
// g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
// RenderingHints.VALUE_STROKE_PURE);
// g2d.setStroke(new BasicStroke(0.5f));
// g2d.draw(outerContour);
// g2d.setColor(Color.blue);
// g2d.draw(innerContour);
borderPainter.paintBorder(
g2d,
this.ribbon,
width,
height + selectedTaskButtonBounds.height + 1,
outerContour,
innerContour,
borderScheme);
// check whether the currently selected task is a contextual task
RibbonTask selected = selectedTask;
RibbonContextualTaskGroup contextualGroup = selected.getContextualGroup();
if (contextualGroup != null) {
// paint a small gradient directly below the task area
Insets ins = this.ribbon.getInsets();
int topY = ins.top + getTaskbarHeight();
int bottomY = topY + 5;
Color hueColor = contextualGroup.getHueColor();
Paint paint =
new GradientPaint(
0,
topY,
FlamingoUtilities.getAlphaColor(
hueColor, (int) (255 * RibbonContextualTaskGroup.HUE_ALPHA)),
0,
bottomY,
FlamingoUtilities.getAlphaColor(hueColor, 0));
g2d.setPaint(paint);
g2d.clip(outerContour);
g2d.fillRect(0, topY, width, bottomY - topY + 1);
}
// paint outlines of the contextual task groups
// paintContextualTaskGroupsOutlines(g);
g2d.dispose();
}