/** @param e */
@Override
public void mouseExited(MouseEvent e) {
exit.setLocation(e.getX(), e.getY());
position.setLocation(e.getX(), e.getY());
checkButton(e);
fireEvent(e);
}
public static String validMove(int pos) {
Point tempPos = new Point(numbPos[pos].x, numbPos[pos].y);
// point to left.
tempPos.setLocation(numbPos[pos].x - 1, numbPos[pos].y);
if (blank.equals(tempPos)) {
return "left";
}
// point to right
tempPos.setLocation(numbPos[pos].x + 1, numbPos[pos].y);
if (blank.equals(tempPos)) {
return "right";
}
// point at down
tempPos.setLocation(numbPos[pos].x, numbPos[pos].y - 1);
if (blank.equals(tempPos)) {
return "down";
}
// point at up
tempPos.setLocation(numbPos[pos].x, numbPos[pos].y + 1);
if (blank.equals(tempPos)) {
return "up";
}
return "none";
}
/**
* Compute the closest point on given segment defined by the given start and end points to the
* given point.
*
* @param pt the point to get the closest point on the given segment
* @param start the start point of the segment
* @param stop the stop point of the segment
* @param destPoint the closest point on the given segment to the given point
* @return the closest distance from the given point to the given segment
*/
static double getClosestPoint(Point pt, Point start, Point stop, Point destPoint) {
double factor = projectionFactor(pt, start, stop);
// the closest point is interior to the segment
if (factor > 0 && factor < 1) {
double x = start.x + factor * (stop.x - start.x);
double y = start.y + factor * (stop.y - start.y);
destPoint.setLocation(x, y);
return destPoint.distance(pt);
}
double dist1 = start.distance(pt);
double dist2 = stop.distance(pt);
// the closest point is the start point of the segment
if (dist1 < dist2) {
destPoint.setLocation(start);
return dist1;
}
// the closest point is the end point of the segment
destPoint.setLocation(stop);
return dist2;
}
/** @param e */
@Override
public void mouseReleased(MouseEvent e) {
mousedown = false;
release.setLocation(e.getX(), e.getY());
position.setLocation(e.getX(), e.getY());
checkButton(e);
fireEvent(e);
}
/** @param e */
@Override
public void mousePressed(MouseEvent e) {
mousedown = true;
press.setLocation(e.getX(), e.getY());
position.setLocation(e.getX(), e.getY());
checkButton(e);
fireEvent(e);
}
/** @param e */
@Override
public void mouseDragged(MouseEvent e) {
mousedrag = true;
drag.setLocation(e.getX(), e.getY());
position.setLocation(e.getX(), e.getY());
checkButton(e);
fireEvent(e);
}
public void moveAnchor(int type, int deltaX, int deltaY) {
if (type == TYPE_HEAD) {
pointHead.setLocation(pointHead.x + deltaX, pointHead.y + deltaY);
} else if (type == TYPE_TAIL) {
pointTail.setLocation(pointTail.x + deltaX, pointTail.y + deltaY);
}
redraw();
}
public void moveAnchor(long guuid, int deltaX, int deltaY) {
if (anchorHeadUUID == guuid) {
pointHead.setLocation(pointHead.x + deltaX, pointHead.y + deltaY);
}
if (anchorTailUUID == guuid) {
pointTail.setLocation(pointTail.x + deltaX, pointTail.y + deltaY);
}
redraw();
}
public static void main(String[] args) {
System.out.println("Enter three points to calculate the area: ");
Scanner reader = new Scanner(System.in);
Point pointA = new Point();
pointA.setLocation(reader.nextInt(), reader.nextInt());
Point pointB = new Point();
pointB.setLocation(reader.nextInt(), reader.nextInt());
Point pointC = new Point();
pointC.setLocation(reader.nextInt(), reader.nextInt());
Double area = calculatingArea(pointA, pointB, pointC);
System.out.println(area);
}
public void render(Graphics g) {
// points used for render culling
// long starter = System.currentTimeMillis();
Point origin =
Globals.findTile(
(int) player.getX() - Camera.width / 2, (int) player.getY() - Camera.height);
Point bottomRight =
Globals.findTile((int) player.getX() + Camera.width, (int) player.getY() + Camera.height);
if (origin.x < 0) origin.setLocation(0, origin.y);
if (origin.y < 0) origin.setLocation(origin.x, 0);
if (bottomRight.x >= xLength) bottomRight.setLocation(xLength - 1, bottomRight.y);
if (bottomRight.y >= yHeight) bottomRight.setLocation(bottomRight.x, yHeight - 1);
ArrayList<Entity> sortList = new ArrayList<Entity>();
for (Entity e : mobList) {
sortList.add(e);
}
// render loop
for (int x = origin.x; x < bottomRight.x; x++) {
for (int y = bottomRight.y; y >= origin.y; y--) {
try {
if (tileMap[x][y] != null) {
// renderct++;
tileMap[x][y].render(g);
}
if (walls[x][y] != null) sortList.add(walls[x][y]);
} catch (Exception e) {
System.out.println("EXCEPTION IN WORLD RENDER LOOP");
e.printStackTrace();
}
;
}
}
Collections.sort(sortList, spriteSorter);
if (player.target != null)
player.selection.render(
g,
(int) ((Mob) player.target).getAttbox().getX() - 10,
(int) ((Mob) player.target).getAttbox().getY() + 130);
for (Entity e : sortList) {
// renderct++;
e.render(g);
}
}
public void mouseDragged(MouseEvent e) {
Point newPos = e.getPoint();
SwingUtilities.convertPointToScreen(newPos, SizeGrip.this);
int xDelta = newPos.x - origPos.x;
int yDelta = newPos.y - origPos.y;
Window wind = SwingUtilities.getWindowAncestor(SizeGrip.this);
if (wind != null) { // Should always be true
if (getComponentOrientation().isLeftToRight()) {
int w = wind.getWidth();
if (newPos.x >= wind.getX()) {
w += xDelta;
}
int h = wind.getHeight();
if (newPos.y >= wind.getY()) {
h += yDelta;
}
wind.setSize(w, h);
} else { // RTL
int newW = Math.max(1, wind.getWidth() - xDelta);
int newH = Math.max(1, wind.getHeight() + yDelta);
wind.setBounds(newPos.x, wind.getY(), newW, newH);
}
// invalidate()/validate() needed pre-1.6.
wind.invalidate();
wind.validate();
}
origPos.setLocation(newPos);
}
/** @param e */
@Override
public void mouseMoved(MouseEvent e) {
mousedrag = false;
position.setLocation(e.getX(), e.getY());
checkButton(e);
fireEvent(e);
}
/**
* Calculates the position of a frame to be in the center of an other frame.
*
* @param parentFrame
* @param frame
* @return
*/
public static Point getCenter(final Component parentFrame, final Window frame) {
final Point point = new Point();
int x = 0, y = 0;
if (parentFrame == null || frame == null) {
point.setLocation(x, y);
return point;
}
x = parentFrame.getLocation().x + parentFrame.getSize().width / 2 - frame.getSize().width / 2;
y = parentFrame.getLocation().y + parentFrame.getSize().height / 2 - frame.getSize().height / 2;
point.setLocation(x, y);
return point;
}
private void showSliderMenu() {
Point location = new Point(getX(), getY() + getHeight());
SwingUtilities.convertPointToScreen(location, InputVolumeControlButton.this.getParent());
if (isFullScreen()) {
location.setLocation(
location.getX(),
location.getY() - sliderMenu.getPreferredSize().getHeight() - getHeight());
}
sliderMenu.setLocation(location);
sliderMenu.addPopupMenuListener(
new PopupMenuListener() {
public void popupMenuWillBecomeVisible(PopupMenuEvent ev) {
sliderMenuIsVisible = true;
}
public void popupMenuWillBecomeInvisible(PopupMenuEvent ev) {
sliderMenuIsVisible = false;
}
public void popupMenuCanceled(PopupMenuEvent ev) {}
});
sliderMenu.setVisible(!sliderMenu.isVisible());
}
public void mousePressed(
java.awt.event.MouseEvent ev,
edu.cmu.cs.stage3.alice.core.Transformable pickedTransformable,
edu.cmu.cs.stage3.alice.scenegraph.renderer.PickInfo pickInfo) {
camera = (edu.cmu.cs.stage3.alice.core.Camera) pickInfo.getSource().getBonus();
pressPoint.setLocation(ev.getPoint());
}
@Override
public void mouseClicked(MouseEvent e) {
if (SwingUtilities.isRightMouseButton(e) && noteData.getSelectedNote() != null) {
final String url =
OsmApi.getOsmApi().getBaseUrl() + "notes/" + noteData.getSelectedNote().getId();
ClipboardUtils.copyString(url);
return;
} else if (!SwingUtilities.isLeftMouseButton(e)) {
return;
}
Point clickPoint = e.getPoint();
double snapDistance = 10;
double minDistance = Double.MAX_VALUE;
final int iconHeight = ImageProvider.ImageSizes.SMALLICON.getAdjustedHeight();
Note closestNote = null;
for (Note note : noteData.getNotes()) {
Point notePoint = Main.map.mapView.getPoint(note.getLatLon());
// move the note point to the center of the icon where users are most likely to click when
// selecting
notePoint.setLocation(notePoint.getX(), notePoint.getY() - iconHeight / 2);
double dist = clickPoint.distanceSq(notePoint);
if (minDistance > dist && clickPoint.distance(notePoint) < snapDistance) {
minDistance = dist;
closestNote = note;
}
}
noteData.setSelectedNote(closestNote);
}
public Point getJoistick() {
double xAng = Math.sin(nunchukJoistickAngle * Math.PI / 180.0) * nunchukJoistickMagnithude;
double yAng = Math.cos(nunchukJoistickAngle * Math.PI / 180.0) * nunchukJoistickMagnithude;
Point p = new Point();
p.setLocation(xAng * 1000, yAng * 1000);
return p;
}
/**
* Rotates a two-dimensional vector by the angle alpha.
*
* @param p Point
* @param alpha double
* @return q Point
*/
public static Point rotate(Point p, double alpha) {
double sina = Math.sin(alpha);
double cosa = Math.cos(alpha);
Point q = new Point();
q.setLocation(p.getX() * cosa - p.getY() * sina, p.getX() * sina + p.getY() * cosa);
return q;
}
public void selected(
edu.cmu.cs.stage3.alice.core.Transformable pickedTransformable,
edu.cmu.cs.stage3.alice.scenegraph.renderer.PickInfo pickInfo,
Point p) {
camera = (edu.cmu.cs.stage3.alice.core.Camera) pickInfo.getSource().getBonus();
pressPoint.setLocation(p);
}
public boolean startDragging(MouseEvent mouseEvent) {
// Get the mouse position and the component of the mouse event.
Component mouseComponent = (Component) mouseEvent.getSource();
int x = mouseEvent.getX();
int y = mouseEvent.getY();
// Reset the fields.
reset();
// Initialize the fields for docking.
// Get the origin dock.
originDock = (LeafDock) SwingUtilities.getAncestorOfClass(LeafDock.class, mouseComponent);
if (originDock != null) {
// Control that the dragged dockable belongs to this dock.
if (originDock.containsDockable(draggedDockable)) {
// Calculate the dockable offset.
dockableOffset.setLocation(x, y);
dockableOffset =
SwingUtilities.convertPoint(
mouseComponent, dockableOffset, draggedDockable.getContent());
// We could find a dockable for dragging.
return true;
}
}
// We could not find a dockable for dragging.
return false;
}
/** Sets the location for predicted pentomino */
public void predictDrop() {
predictedLocation = (Point) pentominoLocation.clone();
while (nextDropLegal(activePentomino, gameBoard.getBoard(), predictedLocation)) {
predictedLocation.setLocation(predictedLocation.getX(), predictedLocation.getY() + 1);
}
}
/**
* Mouse dragged, initiates page panning if the tool is selected.
*
* @param e awt mouse event
*/
public void mouseDragged(MouseEvent e) {
if (documentViewController != null
&& documentViewController.getDocumentViewModel().getViewToolMode()
== DocumentViewModel.DISPLAY_TOOL_PAN) {
// Get data about the current view port position
Adjustable verticalScrollbar = documentViewController.getVerticalScrollBar();
Adjustable horizontalScrollbar = documentViewController.getHorizontalScrollBar();
if (verticalScrollbar != null && horizontalScrollbar != null) {
// calculate how much the view port should be moved
Point p =
new Point(
(int) e.getPoint().getX() - horizontalScrollbar.getValue(),
(int) e.getPoint().getY() - verticalScrollbar.getValue());
int x = (int) (horizontalScrollbar.getValue() - (p.getX() - lastMousePosition.getX()));
int y = (int) (verticalScrollbar.getValue() - (p.getY() - lastMousePosition.getY()));
// apply the pan
horizontalScrollbar.setValue(x);
verticalScrollbar.setValue(y);
// update last position holder
lastMousePosition.setLocation(p);
}
}
}
private void parseFlow() {
for (InstanciaComponente component : componentList) {
component.setEditable(false);
for (FlowStateHistoryTO flowState : flowStateHistory) {
if (component.ID == flowState.getState()) {
touchedBlocks.add(component);
if (StringUtils.isNotBlank(flowState.getExitPort())) {
int index = component.C_B.nomes_saidas.indexOf(flowState.getExitPort());
if (index > -1 && component.C_B.Pontos_Saida.length > index) {
for (List<Conector> conectorList : component.lista_estado_saidas) {
for (Conector conector : conectorList) {
if (conector.Comp instanceof Linha) {
Point point = new Point(component.C_B.Pontos_Saida[index]);
point.setLocation(component.Posicao_X + point.x, component.Posicao_Y + point.y);
Point p1 = ((Linha) conector.Comp).p1;
Point p2 = ((Linha) conector.Comp).p2;
if (p1.equals(point) || p2.equals(point)) {
touchedLines.add((Linha) conector.Comp);
}
}
}
}
}
}
break;
}
}
}
}
public static Point CenterPoint(Dimension size) {
Point loc_p = new Point();
loc_p.setLocation(size.getWidth() / 2, size.getHeight() / 2);
return loc_p;
}
/**
* Deletes a row.
*
* @param row the number of the row to delete
* @return boolean <CODE>true</CODE> if the row was deleted; <CODE>false</CODE> if not
*/
public boolean deleteRow(int row) {
if (row < 0 || row >= rows.size()) {
return false;
}
rows.remove(row);
curPosition.setLocation(curPosition.x - 1, curPosition.y);
return true;
}
/**
* ************************************************************************ * * Name:
* getJumpPoint() * * Description: Finds the next possible directional movement on a HiQ board * *
* Parameters * * INPUT: * pos * A Point instance containing a board coordinate * dir * A String
* containing the direction to go * * OUTPUT: * A new Point instance *
* ************************************************************************
*/
public Point getJumpPoint(Point pos, String dir) {
int column = (int) pos.getX();
int row = (int) pos.getY();
Point p = new Point(0, 0);
if (dir == "left") {
p.setLocation(column, row - 1);
} else if (dir == "right") {
p.setLocation(column, row + 1);
} else if (dir == "up") {
p.setLocation(column - 1, row);
} else if (dir == "down") {
p.setLocation(column + 1, row);
}
return p;
}
private void zentriere(java.awt.Frame hf) {
java.awt.Point OL = hf.getLocationOnScreen();
OL.translate(hf.getWidth() / 2, hf.getHeight() / 2);
OL.translate(-this.getWidth() / 2, -this.getHeight() / 2);
if (OL.getX() < 0) OL.setLocation(0, OL.getY());
if (OL.getY() < 0) OL.setLocation(OL.getX(), 0);
this.setLocation(OL);
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
// Component result = super.getTableCellRendererComponent(table, value, isSelected,
// hasFocus, row, column);
setValue(value);
highlight.setLocation(-1, -1);
hasSeparatorLine = column > 1 && column % 4 == 1;
// ASCII dump
if (column == table.getColumnCount() - 1) {
long selStart = getSmallestSelectionIndex();
long selEnd = getLargestSelectionIndex();
final int hexColumns = model.getNumberOfHexColumns();
int b1 = row * hexColumns;
int b2 = b1 + hexColumns - 1;
if (selStart <= b2 && selEnd >= b1) {
long start = Math.max(selStart, b1) - b1;
long end = Math.min(selEnd, b2) - b1;
highlight.setLocation(start, end);
}
boolean alternateColor = alternateRowBackground && (row & 1) > 0;
setBackground(alternateColor ? alternateCellColor : table.getBackground());
setForeground(asciiDumpColor);
hasSeparatorLine = false;
} else {
if (!isSelected) {
if ((alternateRowBackground && (row & 1) > 0)
^ (alternateColumnBackground && (column & 1) > 0)) {
setBackground(alternateCellColor);
} else {
setBackground(table.getBackground());
}
} else {
setBackground(table.getSelectionBackground());
}
// Offset column
if (column == 0) {
setForeground(offsetColor);
} else {
setForeground(table.getForeground());
}
}
return this;
}
public static Point CenterPoint(Dimension parentSize, Dimension windowSize) {
Point loc_p = new Point();
loc_p.setLocation(
(parentSize.getWidth() / 2) - (windowSize.getWidth() / 2),
(parentSize.getHeight() / 2) - (windowSize.getHeight() / 2));
return loc_p;
}
public void drawSelection(Graphics g, String lastSubstring) {
g.setXORMode(Color.black);
if (activeStart != -1) {
offset2Point(activeStart, false, activePoint);
g.setColor(Color.magenta);
int line = activePoint.x - 1;
g.fillRect(line, activePoint.y, 1, lineHeight);
}
if (selection.isCaret()) {
offset2Point(selection.caret, selection.clickAfter, caretPoint);
} else {
if (focus) g.setColor(Color.blue);
else g.setColor(Color.yellow);
offset2Point(selection.getStart(), true, startPoint);
offset2Point(selection.getEnd(), false, endPoint);
if (selection.getStart() == selection.caret) caretPoint.setLocation(startPoint);
else caretPoint.setLocation(endPoint);
if (startPoint.y == endPoint.y) {
paintRect(
g, startPoint.x, startPoint.y, Math.max(1, endPoint.x - startPoint.x), lineHeight);
} else {
paintRect(
g, startPoint.x, startPoint.y, (mySize.width - xInset) - startPoint.x, lineHeight);
if (startPoint.y + lineHeight < endPoint.y)
paintRect(
g,
xInset,
startPoint.y + lineHeight,
(mySize.width - xInset) - xInset,
endPoint.y - startPoint.y - lineHeight);
paintRect(g, xInset, endPoint.y, endPoint.x - xInset, lineHeight);
}
}
if (focus || selection.isCaret()) {
if (focus) g.setColor(Color.green);
else g.setColor(Color.red);
int line = caretPoint.x - (selection.clickAfter ? 0 : 1);
g.fillRect(line, caretPoint.y, 1, lineHeight);
int w = lineHeight / 12 + 1;
int braces = line - (selection.clickAfter ? -1 : w);
g.fillRect(braces, caretPoint.y, w, 1);
g.fillRect(braces, caretPoint.y + lineHeight - 1, w, 1);
}
}