/**
* Move the component to its new location. The dragged Point must be in the destination
* coordinates.
*/
@Override
public void mouseDragged(MouseEvent e) {
Point dragged = e.getLocationOnScreen();
int dragX = getDragDistance(dragged.x, pressed.x, snapSize.width);
int dragY = getDragDistance(dragged.y, pressed.y, snapSize.height);
int locationX = location.x + dragX;
int locationY = location.y + dragY;
// Mouse dragged events are not generated for every pixel the mouse
// is moved. Adjust the location to make sure we are still on a
// snap value.
while (locationX < edgeInsets.left) {
locationX += snapSize.width;
}
while (locationY < edgeInsets.top) {
locationY += snapSize.height;
}
Dimension d = getBoundingSize(destination);
while (locationX + destination.getSize().width + edgeInsets.right > d.width) {
locationX -= snapSize.width;
}
while (locationY + destination.getSize().height + edgeInsets.bottom > d.height) {
locationY -= snapSize.height;
}
// Adjustments are finished, move the component
destination.setLocation(locationX, locationY);
}
/**
* Draws a simple 3d border for the given component.
*
* @param c The component to draw its border.
* @param g The graphics context.
* @param x The x coordinate of the top left corner.
* @param y The y coordinate of the top left corner.
* @param w The width.
* @param h The height.
*/
public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
boolean isHorizontal = ((JToolBar) c).getOrientation() == HORIZONTAL;
g.setColor(MetouiaLookAndFeel.getControlHighlight());
if (isHorizontal) {
g.drawLine(0, 0, w - 1, 0);
} else {
g.drawLine(0, 0, 0, h - 1);
}
g.setColor(MetouiaLookAndFeel.getControlShadow());
if (isHorizontal) {
g.drawLine(0, h - 1, w - 1, h - 1);
} else {
g.drawLine(w - 1, 0, w - 1, h - 1);
}
g.translate(x, y);
if (((JToolBar) c).isFloatable()) {
if (((JToolBar) c).getOrientation() == HORIZONTAL) {
dots.setDotsArea(5, c.getSize().height - 4);
if (c.getComponentOrientation().isLeftToRight()) {
dots.paintIcon(c, g, 2, 2);
} else {
dots.paintIcon(c, g, c.getBounds().width - 12, 2);
}
} else {
dots.setDotsArea(c.getSize().width - 4, 5);
dots.paintIcon(c, g, 2, 2);
}
}
g.translate(-x, -y);
}
public static void positionComponent(int p, Component c, Rectangle d) {
if (d == null) {
Dimension s = Toolkit.getDefaultToolkit().getScreenSize();
d = new Rectangle(0, 0, s != null ? s.width : 800, s != null ? s.height : 600);
}
switch (p) {
case NORTH_WEST:
c.setLocation(d.x, d.y);
break;
case NORTH:
c.setLocation(d.x + (d.width - c.getSize().width) / 2, d.y);
break;
case NORTH_EAST:
c.setLocation(d.x + (d.width - c.getSize().width), d.y);
break;
case WEST:
c.setLocation(d.x, d.y + (d.height - c.getSize().height) / 2);
break;
case SOUTH_WEST:
c.setLocation(d.x, d.y + (d.height - c.getSize().height));
break;
case EAST:
c.setLocation(d.x + d.width - c.getSize().width, d.y + (d.height - c.getSize().height) / 2);
break;
case SOUTH_EAST:
c.setLocation(
d.x + (d.width - c.getSize().width), d.y + (d.height - c.getSize().height) - 30);
break;
case CENTER:
c.setLocation(
d.x + (d.width - c.getSize().width) / 2, d.y + (d.height - c.getSize().height) / 2);
break;
}
}
/**
* Returns the nth point in this graph (coordinates measured in pixels with respect to the canvas
* provided).
*
* @throws IndexOutOfBoundsException if the graph does not have an nth point.
*/
public Point getPoint(Component canvas, int n) {
// subtract 1 so that everything actually fits *within* the canvas
int width = canvas.getSize().width - 1;
int height = canvas.getSize().height - 1;
int x = xAxis.rescaleDataValue(this.getXValue(n), 0, width);
int y = yAxis.rescaleDataValue(this.getYValue(n), height, 0);
return new Point(x, y);
}
/**
* Setup the variables used to control the moving of the component:
*
* <p>source - the source component of the mouse event destination - the component that will
* ultimately be moved pressed - the Point where the mouse was pressed in the destination
* component coordinates.
*/
@Override
public void mousePressed(MouseEvent e) {
source = e.getComponent();
int width = source.getSize().width - dragInsets.left - dragInsets.right;
int height = source.getSize().height - dragInsets.top - dragInsets.bottom;
Rectangle r = new Rectangle(dragInsets.left, dragInsets.top, width, height);
if (r.contains(e.getPoint())) {
setupForDragging(e);
}
}
public static void center(Component c, Component rel) {
if (rel != null) {
c.setLocation(
rel.getLocation().x + rel.getSize().width / 2 - c.getSize().width / 2,
rel.getLocation().y + rel.getSize().height / 2 - c.getSize().height / 2);
} else {
c.setLocation(
Toolkit.getDefaultToolkit().getScreenSize().width / 2 - c.getSize().width / 2,
+Toolkit.getDefaultToolkit().getScreenSize().height / 2 - c.getSize().height / 2);
}
}
protected void enforceMinimumAndMaximumWidgetSizes(java.awt.Component component) {
java.awt.Dimension size = component.getSize();
boolean changed = false;
// enforce minimum
java.awt.Dimension minimumSize = component.getMinimumSize();
if (size.width < minimumSize.width) {
size.width = minimumSize.width;
changed = true;
}
if (size.height < minimumSize.height) {
size.height = minimumSize.height;
changed = true;
}
// enforce maximum
java.awt.Dimension maximumSize = component.getMaximumSize();
if (maximumSize != null) {
if (size.width > maximumSize.width && maximumSize.width > 0) {
size.width = maximumSize.width;
changed = true;
}
if (size.height > maximumSize.height && maximumSize.height > 0) {
size.height = maximumSize.height;
changed = true;
}
}
if (changed) {
component.setSize(size);
}
}
public void setTarget(Component paramComponent, Insets paramInsets) {
if (this.Target != null) {
this.Target.removeComponentListener(this);
if (this.TargetParent != null) {
this.TargetParent.removeContainerListener(this);
this.TargetParent = null;
}
}
if (paramInsets == null) this.Space = DEFAULTINSETS;
else this.Space = paramInsets;
this.Target = paramComponent;
setLocation(
paramComponent.getLocation().x - this.Space.left,
paramComponent.getLocation().y - this.Space.top);
setSize(
paramComponent.getSize().width + this.Space.left + this.Space.right,
paramComponent.getSize().height + this.Space.top + this.Space.bottom);
paramComponent.addComponentListener(this);
if (this.Target.getParent() != null) {
this.TargetParent = this.Target.getParent();
this.TargetParent.addContainerListener(this);
}
}
public int print(Graphics g, PageFormat format, int page_index) throws PrinterException {
if (page_index > 0) {
return Printable.NO_SUCH_PAGE;
}
// get the bounds of the component
Dimension dim = comp.getSize();
double cHeight = dim.getHeight();
double cWidth = dim.getWidth();
// get the bounds of the printable area
double pHeight = format.getImageableHeight();
double pWidth = format.getImageableWidth();
double pXStart = format.getImageableX();
double pYStart = format.getImageableY();
double xRatio = pWidth / cWidth;
double yRatio = pHeight / cHeight;
Graphics2D g2 = (Graphics2D) g;
g2.translate(pXStart, pYStart);
g2.scale(xRatio, yRatio);
comp.paint(g2);
return Printable.PAGE_EXISTS;
}
/**
* Locates the given component on the screen's center.
*
* @param component the component to be centered
*/
protected final void locateOnOpticalScreenCenter(Component component) {
Dimension paneSize = component.getSize();
Dimension screenSize = component.getToolkit().getScreenSize();
component.setLocation(
(screenSize.width - paneSize.width) / 2,
(int) ((screenSize.height - paneSize.height) * 0.45));
}
/**
* We generally draw lines to/from the <I>center</I> of components; this method finds the center
* of the argument's enclosing rectangle
*
* @return Point at the center of <CODE>c</CODE>
* @param c The component whose center point we wish to determine
*/
protected Point getCenterLocation(Component c) {
Point p1 = new Point();
Point p2 = new Point();
// start with the relative location...
c.getLocation(p1);
// get to the middle of the fractionsLabel
Dimension d = c.getSize();
p1.x += d.width / 2;
p1.y += d.height / 2;
Component parent = c.getParent();
// System.err.println("parent=" + parent);
while (parent != null) {
parent.getLocation(p2);
p1.x += p2.x;
p1.y += p2.y;
if (STOP.equals(parent.getName())) break;
parent = parent.getParent();
}
return p1;
}
public static void captureScreen(Component Area) {
// Find out where the user would like to save their screen shot
String fileName = null;
JFileChooser chooser = new JFileChooser();
FileNameExtensionFilter filter = new FileNameExtensionFilter("Screen Shots", "png");
chooser.setFileFilter(filter);
int returnVal = chooser.showSaveDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File saveFile = new File(chooser.getSelectedFile().getPath() + ".png");
fileName = saveFile.toString();
// Check to see if we will overwrite the file
if (saveFile.exists()) {
int overwrite =
JOptionPane.showConfirmDialog(null, "File already exists, do you want to overwrite?");
if (overwrite == JOptionPane.CANCEL_OPTION
|| overwrite == JOptionPane.CLOSED_OPTION
|| overwrite == JOptionPane.NO_OPTION) {
return;
}
}
}
// If they didn't hit approve, return
else {
return;
}
// Determine the exact coordinates of the screen that is to be captured
Dimension screenSize = Area.getSize();
Rectangle screenRectangle = new Rectangle();
screenRectangle.height = screenSize.height;
screenRectangle.width = screenSize.width;
screenRectangle.x = Area.getLocationOnScreen().x;
screenRectangle.y = Area.getLocationOnScreen().y;
// Here we have to make the GUI Thread sleep for 1/4 of a second
// just to give the save dialog enough time to close off of the
// screen. On slower computers they were capturing the screen
// before the dialog was out of the way.
try {
Thread.currentThread();
Thread.sleep(250);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
// Attempt to capture the screen at the defined location.
try {
Robot robot = new Robot();
BufferedImage image = robot.createScreenCapture(screenRectangle);
ImageIO.write(image, "png", new File(fileName));
} catch (AWTException e) {
e.printStackTrace();
} catch (IOException e) {
JOptionPane.showMessageDialog(null, "Could not save screen shoot at: " + fileName);
e.printStackTrace();
}
}
public static void center(Component c, Rectangle area) {
Dimension size = c.getSize();
int x = area.x + (area.width - size.width >> 1);
int y = area.y + (area.height - size.height >> 1);
c.setLocation(Math.max(0, x), Math.max(0, y));
}
/**
* takes a java component and generates an image out of it.
*
* @param c the component for which image needs to be generated
* @return the generated image
*/
public static BufferedImage captureComponentViewAsBufferedImage(Component c) {
Dimension size = c.getSize();
BufferedImage bufferedImage =
new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
Graphics bufferedGraphics = bufferedImage.createGraphics();
c.paint(bufferedGraphics);
return bufferedImage;
}
private void test() throws Exception {
if (left.getSize().width == 100) {
System.out.println("Test passed");
} else {
throw new RuntimeException(
"ScrollPaneLayout sometimes improperly " + "calculates the preferred layout size. ");
}
}
private Rectangle getTransformedSize() {
if (view != null) {
Dimension viewSize = view.getSize();
Rectangle viewRect = new Rectangle(viewSize);
return at.createTransformedShape(viewRect).getBounds();
}
return new Rectangle(super.getPreferredSize());
}
private void toggleViewState(final Component component, final boolean visible) {
final Dimension size = getSize();
size.height += component.getSize().height * (visible ? -1 : 1);
component.setVisible(!visible);
setMinimumSize(size);
if ((getExtendedState() & Frame.MAXIMIZED_BOTH) != Frame.MAXIMIZED_BOTH) {
pack();
}
}
/*--------------------------------------------------------------------------*/
private void moveComponents(
Container target,
int x,
int y,
int width,
int height,
int rowStart,
int rowEnd,
boolean ltr) {
synchronized (target.getTreeLock()) {
switch (newAlign) {
case LEFT:
x += ltr ? 0 : width;
break;
case CENTER:
x += width / 2;
break;
case RIGHT:
x += ltr ? width : 0;
break;
case LEADING:
break;
case TRAILING:
x += width;
break;
}
for (int i = rowStart; i < rowEnd; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
if (ltr) {
m.setLocation(x, y + (height - m.getSize().height) / 2);
} else {
m.setLocation(
target.getSize().width - x - m.getSize().width,
y + (height - m.getSize().height) / 2);
}
x += m.getSize().width + hgap;
}
}
}
}
public static BufferedImage componentToImage(Component component) {
Dimension componentSize = component.getSize();
BufferedImage image =
new BufferedImage(
(int) componentSize.getWidth(),
(int) componentSize.getHeight(),
BufferedImage.TYPE_INT_RGB);
component.paint(image.createGraphics());
return image;
}
public void paintIcon(Component c, Graphics g, int x, int y) {
Dimension size = c.getSize();
Graphics g2 = g.create(size.width / 2 - 5, size.height / 2 - 5, 10, 10);
g2.setColor(Color.GRAY);
g2.drawPolygon(xPoints, yPoints, 3);
if (c.isEnabled()) {
g2.setColor(Color.BLACK);
g2.fillPolygon(xPoints, yPoints, 3);
}
g2.dispose();
}
public void layoutContainer(Container target) {
// System.out.println("Laying out container " + target);
super.layoutContainer(target);
if (free != null) { // what is free??
Point loc = free.getLocation();
Dimension sz = free.getSize();
// System.out.println("Laying out free component " + free);
free.setBounds(loc.x, loc.y, sz.width, sz.height);
}
}
/** Center a component in the middle of the screen. */
public static void centerComponent(java.awt.Component component) {
java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
java.awt.Dimension size = component.getSize();
screenSize.height = screenSize.height / 2;
screenSize.width = screenSize.width / 2;
size.height = size.height / 2;
size.width = size.width / 2;
component.setLocation(screenSize.width - size.width, screenSize.height - size.height);
}
/**
* Gets the border insets.
*
* @param c the instance of Component
* @return the instance of Insets
*/
public Insets getBorderInsets(Component c) {
Dimension currentComponent = c.getSize();
if (currentComponent.equals(lastComponentSize)) {
return insets;
}
insets = new Insets(thickness, thickness, thickness, thickness);
lastComponentSize = currentComponent;
return insets;
}
private static void center(final Component wind, final Rectangle rect) {
if ((wind == null) || (rect == null)) {
return;
}
final Dimension windSize = wind.getSize();
final int x = ((rect.width - windSize.width) / 2) + rect.x;
int y = ((rect.height - windSize.height) / 2) + rect.y;
if (y < rect.y) {
y = rect.y;
}
wind.setLocation(x, y);
}
/** Computes the declared size on the EventDispatcherThread. */
public void run() {
retval = null;
try {
final Component component = getComponent();
if (component instanceof Window == false && isOwnPeerConnected() == false) {
peerSupply.pack();
contentPane.add(component);
}
retval = component.getSize();
} finally {
cleanUp();
}
}
private void paintFocusBorders(boolean clean) {
if (myCurrent != null) {
Graphics currentFocusGraphics = myCurrent.getGraphics();
if (currentFocusGraphics != null) {
if (clean) {
if (myCurrent.isDisplayable()) {
myCurrent.repaint();
}
} else {
currentFocusGraphics.setColor(myTemporary ? JBColor.ORANGE : JBColor.GREEN);
UIUtil.drawDottedRectangle(
currentFocusGraphics,
1,
1,
myCurrent.getSize().width - 2,
myCurrent.getSize().height - 2);
}
}
}
if (myPrevious != null) {
Graphics previousFocusGraphics = myPrevious.getGraphics();
if (previousFocusGraphics != null) {
if (clean) {
if (myPrevious.isDisplayable()) {
myPrevious.repaint();
}
} else {
previousFocusGraphics.setColor(JBColor.RED);
UIUtil.drawDottedRectangle(
previousFocusGraphics,
1,
1,
myPrevious.getSize().width - 2,
myPrevious.getSize().height - 2);
}
}
}
}
/* Constructor */
public MovingObject(
int radius,
int x,
int y,
double vx,
double vy,
double mass,
double k,
Planet planet,
Color color,
AudioClip collision,
Component parent,
int panelHeight) {
this.radius = radius;
pos_x = x;
pos_y = y;
x_speed = vx;
y_speed = vy;
ballMass = mass;
this.k = k; // arbitrary constant used for gravity
this.planet = planet;
this.parent = parent;
this.panelHeight = panelHeight;
x_leftout = radius;
x_rightout = parent.getSize().width - radius;
y_upout = radius + panelHeight;
y_downout = parent.getSize().height - radius;
this.color = color;
img = ((Applet) parent).getImage(((Applet) parent).getCodeBase(), "earth.gif");
this.collision = collision;
}
public static void wallPaper(Component component, Graphics g, Image image) {
Dimension compsize = component.getSize();
Util.waitForImage(component, image);
int patchW = image.getWidth(component);
int patchH = image.getHeight(component);
Assert.isTrue(patchW != -1 && patchH != -1);
for (int r = 0; r < compsize.width; r += patchW) {
for (int c = 0; c < compsize.height; c += patchH) g.drawImage(image, r, c, component);
}
}
/**
* Center on screen
*
* @param thisComponent component to center
*/
public static void center(final Component thisComponent) {
final Dimension thisScreenSize = Toolkit.getDefaultToolkit().getScreenSize();
final Dimension thisComponentSize = thisComponent.getSize();
if (thisComponentSize.height > thisScreenSize.height) {
thisComponentSize.height = thisScreenSize.height;
}
if (thisComponentSize.width > thisScreenSize.width) {
thisComponentSize.width = thisScreenSize.width;
}
thisComponent.setLocation(
(thisScreenSize.width - thisComponentSize.width) / 2,
(thisScreenSize.height - thisComponentSize.height) / 2);
}
/**
* Method to set the mouse dragged actions
*
* @param e
*/
public void mouseDragged(MouseEvent e) {
if (dragging) {
Point p = e.getPoint();
int x = p.x - offset.x;
int y = p.y - offset.y;
Dimension d = selectedComponent.getSize();
selectedComponent.setBounds(x, y, d.width, d.height);
if (!selected) {
activePanel.repaint();
selected = false;
}
glassPanel.repaint();
}
}
