glen/CaRMtl
1
0
Fork 0
Code Issues 6 Pull Requests Releases Wiki Activity
master
CaRMtl/rene/zirkel/objects/PointObject.java

1749 lines
53 KiB
Java
Raw Permalink Normal View History

Make first real commit: copy of CaRMetal 4.2.8
2018-09-05 02:51:42 +00:00
/*
Copyright 2006 Rene Grothmann, modified by Eric Hakenholz
This file is part of C.a.R. software.
C.a.R. is a free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.
C.a.R. 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 for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// with addons by Dibs for 3D
package rene.zirkel.objects;
// file: PointObject.java
import eric.GUI.pipe_tools;
import eric.GUI.palette.PaletteManager;
import eric.JPointName;
import eric.JZirkelCanvas;
import java.awt.Color;
import java.awt.Rectangle;
import java.util.Enumeration;
import java.util.Vector;
import rene.gui.Global;
import rene.util.xml.XmlWriter;
import rene.zirkel.ZirkelCanvas;
import rene.zirkel.construction.Construction;
import rene.zirkel.expression.Expression;
import rene.zirkel.expression.ExpressionColor;
import rene.zirkel.graphics.MainGraphics;
import rene.zirkel.graphics.MyGraphics;
import rene.zirkel.structures.MagnetObj;
public class PointObject extends ConstructionObject implements MoveableObject,
DriverObject {
protected double X, Y;
protected double X3D, Y3D, Z3D;
protected boolean Is3D; //Dibs : the point is 3D
protected boolean BarycentricCoordsInitialzed=false;
protected double Gx=0, Gy=0; // Barycentric coords, if it's inside a
// polygon.
protected double Alpha; // parameter relative zu object
protected boolean AlphaValid=false; // Alpha is valid
protected boolean UseAlpha=false; // Use Alpha at all
protected boolean Moveable, Fixed;
protected boolean Fixed3D; //Dibs
// private static Count N=new Count();
private static JPointName PointLabel=new JPointName();
protected int Type=0;
public double RDP2=16;
public final static int SQUARE=0, DIAMOND=1, CIRCLE=2, DOT=3,
CROSS=4, DCROSS=5;
public static int MaxType=3;
protected Expression EX, EY;
protected Expression EX3D, EY3D, EZ3D;
// private ConstructionObject Bound=null; // point is on a line etc.
private boolean Later; // bound is later in construction
private String LaterBind="";
private boolean KeepInside; // keep point inside bound
private boolean DontUpdate=false;
private double Increment=0; // increment to keep on grid
private ConstructionObject Bound=null; // point is on a line etc.
private double BoundOrder=Double.NaN; // Only for points on parametric
// curves made with "points only"
protected ConstructionObject MovedBy;
private double LASTX=Double.NaN, LASTY=Double.NaN;
private final Vector magnetObjects=new Vector();
Expression magnetRayExp=null;
private int CurrentMagnetRay=Integer.MIN_VALUE;
private ConstructionObject CurrentMagnetObject=null;
public ConstructionObject VirtualBound=null;
// The object that may have moved this point
public PointObject(final Construction c, final double x, final double y) {
super(c);
X=x;
Y=y;
Is3D=false;
X3D=0;
Y3D=0;
Z3D=0;
Moveable=true;
Fixed=false;
Fixed3D=false;
setColor(ColorIndex, SpecialColor);
setShowName(false);
updateText();
Type=0;
setMagnetRayExp("20");
}
public PointObject(final Construction c, final double x, final double y,
final ConstructionObject bound) {
this(c, x, y);
Bound=bound;
initAlpha();
updateText();
}
public PointObject(final Construction c, final String name) {
super(c, name);
X=0;
Y=0;
Is3D=false;
X3D=0;
Y3D=0;
Z3D=0;
Moveable=true;
Fixed=false;
Fixed3D=false;
setColor(ColorIndex, SpecialColor);
updateText();
Type=0;
setMagnetRayExp("20");
}
public void initAlpha() {
if ((Bound!=null)&&(Bound instanceof PrimitiveCircleObject)) {
PrimitiveCircleObject circ=(PrimitiveCircleObject) Bound;
if (circ.hasRange()&&(circ.StartPt!=this)&&(circ.EndPt!=this)&&(isPointOn())) {
circ.detectArc3Pts();
double soe=circ.computeSOE();
double sop=circ.computeSOP(this);
if (soe!=0) {
setAlpha(sop/soe);
// if (circ.isArc3pts&&!circ.StartPt.equals(circ.RealCorrespondingStartPt)) {
// setAlpha(1-sop/soe);
// }
}
}
}
}
public static void setPointLabel(final JPointName jpl) {
PointLabel=jpl;
}
@Override
public void setName() {
if ((!SuperHidden)&&(!Hidden)) {
Name=PointLabel.getBetterName(Cn, false);
} else {
Name=JPointName.getGenericName(Cn);
}
}
@Override
public void setNameWithNumber(String n) {
Name="";
if (Cn!=null) {
ConstructionObject o=Cn.find(n);
if (o!=null) {
while (o!=null&&o!=this) {
Name=JPointName.getGenericName(Cn);
n=Name;
Name="";
o=Cn.find(n);
}
Name=n;
} else {
Name=n;
}
} else {
Name=n;
}
}
@Override
public String getTag() {
if (Bound==null) {
return "Point";
} else {
return "PointOn";
}
}
@Override
public int getN() {
return N.next();
}
// public void setDefaults ()
// { super.setDefaults();
// Type=Cn.DefaultType;
// }
@Override
public void setDefaults() {
setShowName(Global.getParameter("options.point.shownames", false));
setShowValue(Global.getParameter("options.point.showvalues", false));
setColor(Global.getParameter("options.point.color", 0), Global.getParameter("options.point.pcolor", (ExpressionColor) null, this));
setColorType(Global.getParameter("options.point.colortype", 0));
setHidden(Cn.Hidden);
setObtuse(Cn.Obtuse);
setSolid(Cn.Solid);
setLarge(Global.getParameter("options.point.large", false));
setBold(Global.getParameter("options.point.bold", false));
Type=Cn.DefaultType;
}
@Override
public void setTargetDefaults() {
setShowName(Global.getParameter("options.point.shownames", false));
setShowValue(Global.getParameter("options.point.showvalues", false));
setColor(Global.getParameter("options.point.color", 0), Global.getParameter("options.point.pcolor", (ExpressionColor) null, this));
setColorType(Global.getParameter("options.point.colortype", 0));
setLarge(Global.getParameter("options.point.large", false));
setBold(Global.getParameter("options.point.bold", false));
Type=Cn.DefaultType;
}
private double Delta;
@Override
public double changedBy() {
return Delta;
}
@Override
synchronized public void validate() {
if (DontUpdate) {
return;
}
updateMagnetObjects();
followMagnetObject();
// magnet();
// System.out.println(getName()+" : validate !");
MovedBy=null;
Delta=0.0;
Valid=true;
if (Fixed3D&&EX3D!=null&&EX3D.isValid()) {
try {
X3D=EX3D.getValue();
} catch (final Exception e) {
Valid=false;
return;
}
}
if (Fixed3D&&EY3D!=null&&EY3D.isValid()) {
try {
Y3D=EY3D.getValue();
} catch (final Exception e) {
Valid=false;
return;
}
}
if (Fixed3D&&EZ3D!=null&&EZ3D.isValid()) {
try {
Z3D=EZ3D.getValue();
} catch (final Exception e) {
Valid=false;
return;
}
}
if (Fixed&&EX!=null&&EX.isValid()) {
try {
X=EX.getValue();
} catch (final Exception e) {
Valid=false;
return;
}
}
if (Fixed&&EY!=null&&EY.isValid()) {
try {
Y=EY.getValue();
} catch (final Exception e) {
Valid=false;
return;
}
}
if (Bound!=null&&!Bound.isInConstruction()) {
Bound=null;
}
if (Bound!=null&&!Bound.valid()) {
Valid=false;
return;
}
if (Increment>1e-4) {
X=Math.floor(X/Increment+0.5)*Increment;
Y=Math.floor(Y/Increment+0.5)*Increment;
}
if (Bound!=null) {
final double x=X, y=Y;
if (KeepInside&&Bound instanceof InsideObject) {
((InsideObject) Bound).keepInside(this);
} else if (!KeepInside&&Bound instanceof PointonObject) {
if (!AlphaValid||!UseAlpha) {
project(Bound);
} else {
project(Bound, Alpha);
}
}
if (Later) {
Delta=Math.sqrt((x-X)*(x-X)+(y-Y)*(y-Y));
}
}
if (getConstruction().is3D()&&getBound()!=null) { // Dibs : 2D -> 3D
if (getBound() instanceof AreaObject) {
AreaObject surface= (AreaObject) getBound();
if (((AreaObject)surface).V.size()>2&&((PointObject) surface.V.get(0)).is3D()&&((PointObject) surface.V.get(1)).is3D()&&((PointObject) surface.V.get(2)).is3D()) {
try {
double x0=((PointObject) surface.V.get(0)).getX3D();
double y0=((PointObject) surface.V.get(0)).getY3D();
double z0=((PointObject) surface.V.get(0)).getZ3D();
double x1=((PointObject) surface.V.get(1)).getX3D();
double y1=((PointObject) surface.V.get(1)).getY3D();
double z1=((PointObject) surface.V.get(1)).getZ3D();
double x2=((PointObject) surface.V.get(2)).getX3D();
double y2=((PointObject) surface.V.get(2)).getY3D();
double z2=((PointObject) surface.V.get(2)).getZ3D();
double x_O=getConstruction().find("O").getX();
double x_X=getConstruction().find("X").getX();
double x_Y=getConstruction().find("Y").getX();
double x_Z=getConstruction().find("Z").getX();
double y_O=getConstruction().find("O").getY();
double y_X=getConstruction().find("X").getY();
double y_Y=getConstruction().find("Y").getY();
double y_Z=getConstruction().find("Z").getY();
double coeffa=(x1-x0)*(x_X-x_O)+(y1-y0)*(x_Y-x_O)+(z1-z0)*(x_Z-x_O);
double coeffb=(x2-x0)*(x_X-x_O)+(y2-y0)*(x_Y-x_O)+(z2-z0)*(x_Z-x_O);
double coeffc=(x1-x0)*(y_X-y_O)+(y1-y0)*(y_Y-y_O)+(z1-z0)*(y_Z-y_O);
double coeffd=(x2-x0)*(y_X-y_O)+(y2-y0)*(y_Y-y_O)+(z2-z0)*(y_Z-y_O);
double coeffe=getX()-x_O-x0*(x_X-x_O)-y0*(x_Y-x_O)-z0*(x_Z-x_O);
double coefff=getY()-y_O-x0*(y_X-y_O)-y0*(y_Y-y_O)-z0*(y_Z-y_O);
double alpha1=(coeffe*coeffd-coefff*coeffb)/(coeffa*coeffd-coeffb*coeffc);
double beta1=(coeffa*coefff-coeffc*coeffe)/(coeffa*coeffd-coeffb*coeffc);
setX3D(x0+alpha1*(x1-x0)+beta1*(x2-x0));
setY3D(y0+alpha1*(y1-y0)+beta1*(y2-y0));
setZ3D(z0+alpha1*(z1-z0)+beta1*(z2-z0));
setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
AlphaValid=false;
setIs3D(true);
} catch (final Exception eBary) {
}
}
}
else if (getBound() instanceof TwoPointLineObject) {
TwoPointLineObject ligne= (TwoPointLineObject) getBound();
if (((PointObject) ligne.getP1()).is3D()&&((PointObject) ligne.getP2()).is3D()) {
try {
double x1=((PointObject) ligne.getP1()).getX3D();
double y1=((PointObject) ligne.getP1()).getY3D();
double z1=((PointObject) ligne.getP1()).getZ3D();
double x2=((PointObject) ligne.getP2()).getX3D();
double y2=((PointObject) ligne.getP2()).getY3D();
double z2=((PointObject) ligne.getP2 ()).getZ3D();
double x_O=getConstruction().find("O").getX();
double x_X=getConstruction().find("X").getX();
double x_Y=getConstruction().find("Y").getX();
double x_Z=getConstruction().find("Z").getX();
double alpha1=(getX()-x_O-x1*(x_X-x_O)-y1*(x_Y-x_O)-z1*(x_Z-x_O))/((x2-x1)*(x_X-x_O)+(y2-y1)*(x_Y-x_O)+(z2-z1)*(x_Z-x_O));
if (x1==x2&&y1==y2) {
double y_O=getConstruction().find("O").getY();
double y_X=getConstruction().find("X").getY();
double y_Y=getConstruction().find("Y").getY();
double y_Z=getConstruction().find("Z").getY();
alpha1=(getY()-y_O-x1*(y_X-y_O)-y1*(y_Y-y_O)-z1*(y_Z-y_O))/((x2-x1)*(y_X-y_O)+(y2-y1)*(y_Y-y_O)+(z2-z1)*(y_Z-y_O));
}
setX3D(x1+alpha1*(x2-x1));
setY3D(y1+alpha1*(y2-y1));
setZ3D(z1+alpha1*(z2-z1));
setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
//setMoveable(true);
//AlphaValid=false;
setIs3D(true);
} catch (final Exception eBary) {
}
}
}
else if (getBound() instanceof QuadricObject) {
QuadricObject quadrique= (QuadricObject) getBound();
if (quadrique.getP()[0].is3D()&&quadrique.getP()[1].is3D()&&quadrique.getP()[2].is3D()&&quadrique.getP()[3].is3D()&&quadrique.getP()[4].is3D()) {
try {
double x0=quadrique.getP()[0].getX3D();
double y0=quadrique.getP()[0].getY3D();
double z0=quadrique.getP()[0].getZ3D();
double x1=quadrique.getP()[1].getX3D();
double y1=quadrique.getP()[1].getY3D();
double z1=quadrique.getP()[1].getZ3D();
double x2=quadrique.getP()[2].getX3D();
double y2=quadrique.getP()[2].getY3D();
double z2=quadrique.getP()[2].getZ3D();
double x_O=getConstruction().find("O").getX();
double x_X=getConstruction().find("X").getX();
double x_Y=getConstruction().find("Y").getX();
double x_Z=getConstruction().find("Z").getX();
double y_O=getConstruction().find("O").getY();
double y_X=getConstruction().find("X").getY();
double y_Y=getConstruction().find("Y").getY();
double y_Z=getConstruction().find("Z").getY();
double coeffa=(x1-x0)*(x_X-x_O)+(y1-y0)*(x_Y-x_O)+(z1-z0)*(x_Z-x_O);
double coeffb=(x2-x0)*(x_X-x_O)+(y2-y0)*(x_Y-x_O)+(z2-z0)*(x_Z-x_O);
double coeffc=(x1-x0)*(y_X-y_O)+(y1-y0)*(y_Y-y_O)+(z1-z0)*(y_Z-y_O);
double coeffd=(x2-x0)*(y_X-y_O)+(y2-y0)*(y_Y-y_O)+(z2-z0)*(y_Z-y_O);
double coeffe=getX()-x_O-x0*(x_X-x_O)-y0*(x_Y-x_O)-z0*(x_Z-x_O);
double coefff=getY()-y_O-x0*(y_X-y_O)-y0*(y_Y-y_O)-z0*(y_Z-y_O);
double alpha1=(coeffe*coeffd-coefff*coeffb)/(coeffa*coeffd-coeffb*coeffc);
double beta1=(coeffa*coefff-coeffc*coeffe)/(coeffa*coeffd-coeffb*coeffc);
setX3D(x0+alpha1*(x1-x0)+beta1*(x2-x0));
setY3D(y0+alpha1*(y1-y0)+beta1*(y2-y0));
setZ3D(z0+alpha1*(z1-z0)+beta1*(z2-z0));
setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
//AlphaValid=false;
setIs3D(true);
} catch (final Exception eBary) {
}
}
}
}
}
@Override
public Boolean is2DObject(){
return !Is3D;
}
@Override
public void updateText() {
if (Bound!=null) {
setText(text1(Global.name("text.boundedpoint"), Bound.getName()));
//setText(Global.Loc("objects.boundedpoint"));
} else if (EX!=null&&EY!=null) {
// setText(text2(Global.name("text.point"), "\""+EX+"\"", "\""+EY+"\""));
setText(Global.Loc("objects.point"));
} else {
// setText(text2(Global.name("text.point"), ""+round(X), ""+round(Y)));
setText(Global.Loc("objects.point"));
}
}
static double x[]=new double[4], y[]=new double[4];
@Override
public void paint(final MyGraphics g, final ZirkelCanvas zc) {
DisplaysText=false;
if (!Valid||mustHide(zc)) {
return;
}
final double size=drawPoint(g, zc, this, X, Y, Type);
if (tracked()) {
zc.UniversalTrack.drawTrackPoint(this, X, Y, Type);
}
final String s=AngleObject.translateToUnicode(getDisplayText());
if (!s.equals("")) {
g.setLabelColor(this);
DisplaysText=true;
setFont(g);
final double d=Math.sqrt(XcOffset*XcOffset+YcOffset*YcOffset);
if (!KeepClose||d<1e-10) {
TX1=zc.col(X+XcOffset)+2*size;
TY1=zc.row(Y+YcOffset)+2*size;
drawLabel(g, s);
} else {
drawPointLabel(g, s, zc, X, Y, YcOffset/d, -XcOffset/d, 0,
0);
}
}
}
static public double drawPoint(final MyGraphics g, final ZirkelCanvas zc,
final ConstructionObject o, final double X, final double Y,
final int type) {
double size=zc.pointSize();
final double r=zc.col(X), c=zc.row(Y);
final double un=zc.getOne();
// if (size<1) {
// size=1;
// }
// System.out.println(size);
if (o.visible(zc)) {
if (o.isStrongSelected()&&g instanceof MainGraphics) {
((MainGraphics) g).drawMarkerLine(r, c, r, c);
}
g.setColor(o);
switch (type) {
case SQUARE:
final double sx=r-size-un,
sy=c-size-un,
sw=2*(size+un);
if (o.getColorType()==THICK) {
g.fillRect(sx, sy, sw, sw, true, false, o);
} else {
g.fillRect(sx, sy, sw, sw, new Color(255, 255, 255));
}
g.setColor(o);
g.drawRect(sx, sy, sw, sw);
break;
case DIAMOND:
final double dx=r-size-un,
dy=c-size-un,
dw=2*(size+un);
g.drawDiamond(dx, dy, dw, (o.getColorType()==THICK), o);
break;
case CIRCLE:
double cx=r-size-un,
cy=c-size-un,
cw=2*size+2*un;
if (o.getColorType()==THICK) {
g.fillOval(cx, cy, cw, cw, true, false, o);
} else {
g.fillOval(cx, cy, cw, cw, new Color(255, 255, 255));
g.setColor(o);
g.drawOval(cx, cy, cw, cw);
}
break;
case DOT:
if (o.getColorType()==THICK) {
g.fillRect(r, c, un, un, true, false, o);
} else {
g.drawLine(r, c, r, c);
}
break;
case CROSS:
if (o.getColorType()==THICK) {
g.drawThickLine(r-size-un, c, r+size+un, c);
g.drawThickLine(r, c-size-un, r, c+size+un);
} else {
g.drawLine(r-size-un, c, r+size+un, c);
g.drawLine(r, c-size-un, r, c+size+un);
}
break;
case DCROSS:
final double crx=r-size-un,
cry=c-size-un,
crw=2*(size+un);
if (o.getColorType()==THICK) {
g.drawThickLine(crx, cry, crx+crw, cry+crw);
g.drawThickLine(crx+crw, cry, crx, cry+crw);
} else {
g.drawLine(crx, cry, crx+crw, cry+crw);
g.drawLine(crx+crw, cry, crx, cry+crw);
}
break;
}
}
return size;
}
@Override
public String getDisplayValue() {
if (is3D()||PaletteManager.isSelected("boundedpoint")) return "("+Global.getLocaleNumber(X3D, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
:";")+Global.getLocaleNumber(Y3D, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
:";")+Global.getLocaleNumber(Z3D, "lengths")+")";
else return "("+Global.getLocaleNumber(X, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
:";")+Global.getLocaleNumber(Y, "lengths")+")";
}
@Override
public String getCDPDisplayValue() {
return "("+Global.getCDPLocaleNumber(X, 2)+" "+(Global.getParameter("options.germanpoints", false)?"|"
:";")+Global.getCDPLocaleNumber(Y, 2)+")";
}
@Override
public boolean isInRect(Rectangle r, ZirkelCanvas zc){
return r.contains(zc.col(X),zc.row(Y));
}
@Override
public boolean nearto(final int x, final int y, final ZirkelCanvas zc) {
if (!displays(zc)) {
return false;
}
final double c=zc.col(X), r=zc.row(Y);
final int size=(int) zc.selectionSize();
Value=Math.abs(x-c)+Math.abs(y-r);
return Value<=size*3/2;
}
public boolean nearto(final PointObject p) {
try {
X=EX.getValue();
} catch (final Exception e) {
Valid=false;
return false;
}
try {
Y=EY.getValue();
} catch (final Exception e) {
Valid=false;
return false;
}
if (!Valid) {
return false;
}
final double dx=p.X-X, dy=p.Y-Y;
return Math.sqrt(dx*dx+dy*dy)<1e-9;
}
public double distanceTo(final int x, final int y, final ZirkelCanvas zc) {
final double dx=x-zc.col(X), dy=y-zc.row(Y);
return Math.sqrt(dx*dx+dy*dy);
}
@Override
public double getX() {
return X;
}
@Override
public double getY() {
return Y;
}
@Override
public double getX3D() {
return X3D;
}
@Override
public double getY3D() {
return Y3D;
}
@Override
public double getZ3D() {
return Z3D;
}
public void setX3D(double x) {
X3D = x;
}
public void setY3D(double y) {
Y3D = y;
}
public void setZ3D(double z) {
Z3D = z;
}
public boolean is3D() {
return Is3D;
}
public void setIs3D(boolean u) {
Is3D = u;
}
@Override
public boolean moveable() {
boolean fixed=Fixed;
boolean fixed3D=Fixed3D;
if (dependsOnItselfOnly()) {
fixed=false;
}
if (Is3D) return Moveable&&!fixed3D&&!Keep;
else return Moveable&&!fixed&&!Keep;
}
/**
* Check if the point depends on itself and no other object. Such points are
* moveable, even if they are fixed.
*
* @return
*/
public boolean dependsOnItselfOnly() {
boolean res=false;
Enumeration e=depending();
while (e.hasMoreElements()) {
if ((ConstructionObject) e.nextElement()==this) {
res=true;
break;
}
}
e=depending();
while (e.hasMoreElements()) {
if ((ConstructionObject) e.nextElement()!=this) {
res=false;
break;
}
}
return res;
}
public boolean dependsOnParametersOnly() {
final Enumeration e=depending();
while (e.hasMoreElements()) {
if (!((ConstructionObject) e.nextElement()).isParameter()) {
return false;
}
}
return true;
}
/**
* @return o can move this point (moveable and not moved by something else)
*/
public boolean moveableBy(final ConstructionObject o) {
if (Bound!=null) {
return false;
}
return moveable()&&(MovedBy==null||MovedBy==o);
}
public boolean moveablePoint() {
if (Bound!=null) {
return true;
}
return Moveable&&!Keep;
}
public boolean setBound(final String name) {
if (name.equals("")) {
Bound=null;
setFixed(false);
setFixed3D(false);
Later=false;
return true;
}
try {
Bound=null;
final ConstructionObject o=Cn.find(name);
if (o instanceof PointonObject) {
Bound=o;
Moveable=true;
Fixed=false;
Fixed3D=false;
KeepInside=false;
} else if (o instanceof InsideObject) {
Bound=o;
Moveable=true;
Fixed=false;
Fixed3D=false;
KeepInside=true;
} else {
return false;
}
} catch (final Exception e) {
return false;
}
if (Cn.before(this, Bound)) {
Cn.needsOrdering();
Cn.dovalidate();
}
updateText();
clearMagnetObjects();
return true;
}
public void setBound(final ConstructionObject bound) {
Bound=bound;
}
public boolean haveBoundOrder() {
return (!Double.isNaN(BoundOrder));
}
public void setBoundOrder(final double boundorder) {
BoundOrder=boundorder;
}
public void clearBoundOrder() {
BoundOrder=Double.NaN;
}
public ConstructionObject getBound() {
return Bound;
}
public double getBoundOrder() {
return BoundOrder;
}
public void setMoveable(final boolean flag) {
Moveable=flag;
}
@Override
public boolean fixed() {
return Fixed;
}
@Override
public void setFixed(final boolean flag) {
Fixed=flag;
if (!Fixed) {
EX=EY=null;
}
updateText();
}
public boolean fixed3D() {
return Fixed3D;
}
@Override
public void setFixed3D(final boolean flag) {
Fixed3D=flag;
if (!Fixed3D) {
EX3D=null;
EY3D=null;
EZ3D=null;
}
updateText();
}
@Override
public void setFixed(final String x, final String y) {
Fixed=true;
EX=new Expression(x, getConstruction(), this);
EY=new Expression(y, getConstruction(), this);
updateText();
}
@Override
public void setFixed(final String x3D, final String y3D, final String z3D) {
Fixed3D=true;
EX3D=new Expression(x3D, getConstruction(), this);
EY3D=new Expression(y3D, getConstruction(), this);
EZ3D=new Expression(z3D, getConstruction(), this);
setFixed("x(O)+("+EX3D+")*(x(X)-x(O))+("+EY3D+")*(x(Y)-x(O))+("+EZ3D+")*(x(Z)-x(O))", "y(O)+("+EX3D+")*(y(X)-y(O))+("+EY3D+")*(y(Y)-y(O))+("+EZ3D+")*(y(Z)-y(O))");
updateText();
}
public void validCoordinates() throws Exception {
boolean val=(EX.isValid())&&(EY.isValid());
if (!val) {
throw new Exception("");
}
}
public void validCoordinates3D() throws Exception {
boolean val=(EX3D.isValid())&&(EY3D.isValid())&&(EZ3D.isValid());
if (!val) {
throw new Exception("");
}
}
/* This part is for "monkey" animation. Point have a spin and it keeps going
* until it reaches a window border. At this time, spin is recomputed and moves
* following its new trajectory.
*/
private double spin=Math.random()*2*Math.PI;
public boolean insidewindow() {
return insidewindow(X, Y);
}
public boolean insidewindow(double x, double y) {
boolean b=(x>Cn.getX()-Cn.getW());
b=b&&(x<Cn.getX()+Cn.getW());
b=b&&(y<Cn.getY()+Cn.getH()/2);
b=b&&(y>Cn.getY()-Cn.getH()/2);
return b;
}
public void shake(ZirkelCanvas zc) {
if(zc.isDP()){
FixedCircleObject c = (FixedCircleObject) zc.getConstruction().find("Hz");
if(c!=null){
RDP2=c.getR();
RDP2*=RDP2; //set to the square
}
}
if (!insidewindow(X, Y)||(zc.isDP()&&(X*X+Y*Y>RDP2))) {
return;
}
spin+=Math.random()-0.5;
double d=zc.monkeySpeed()/4;
double x=X+d*Math.cos(spin)/Cn.getPixel();
double y=Y+d*Math.sin(spin)/Cn.getPixel();
while (!insidewindow(x, y)||(zc.isDP()&&(x*x+y*y>RDP2))) {
// spin=Math.random()*2*Math.PI;
//demi-tour carrément
spin+=Math.PI;
x=X+d*Math.cos(spin)/Cn.getPixel();
y=Y+d*Math.sin(spin)/Cn.getPixel();
}
move(x, y);
// magnet();
validate();
}
/* this part is for exercise purpose :
*
*/
public void alea() {
if (!insidewindow(X, Y)) {
return;
}
double left=Cn.getX()-Cn.getW();
double top=Cn.getY()+Cn.getH()/2;
double x=left+Math.random()*2*Cn.getW();
double y=top-Math.random()*Cn.getH();
while (!insidewindow(x, y)) {
x=left+Math.random()*2*Cn.getW();
y=top-Math.random()*Cn.getH();
}
move(x, y);
// magnet();
validate();
}
@Override
public void move(final double x, final double y) {
if ((X==x)&&(Y==y)) {
return;
}
// System.out.println(getName()+" : move !");
X=x;
Y=y;
AlphaValid=false;
computeBarycentricCoords();
}
@Override
public void move3D(final double x3D, final double y3D, final double z3D) {
if ((X3D==x3D)&&(Y3D==y3D)&&(Z3D==z3D)) {
return;
}
// System.out.println(getName()+" : move !");
X3D=x3D;
Y3D=y3D;
Z3D=z3D;
AlphaValid=false;
setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
setFixed3D(false);
//computeBarycentricCoords();
}
public void setXY(final double x, final double y) {
if ((X==x)&&(Y==y)) {
return;
}
// System.out.println(getName()+" : setXY !");
X=x;
Y=y;
}
public void setXYZ(final double x3D, final double y3D, final double z3D) {
if ((X3D==x3D)&&(Y3D==y3D)&&(Z3D==z3D)) {
return;
}
// System.out.println(getName()+" : setXY !");
X3D=x3D;
Y3D=y3D;
Z3D=z3D;
setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
}
public void setXYaway(final double x, final double y, final int r) {
if (r>0) {
setXY(x, y);
return;
}
final double d=Math.sqrt((X-x)*(X-x)+(Y-y)*(Y-y));
final double dblr=-r/Cn.getPixel();
double xx=x+dblr, yy=y;
if (d!=0) {
xx=x+(X-x)*dblr/d;
yy=y+(Y-y)*dblr/d;
}
// System.out.println(Cn.getPixel());
// System.out.println("d="+d);
// System.out.println("xx="+xx);
// System.out.println("yy="+yy);
// System.out.println("****");
setXY(xx, yy);
}
public void setA(final double alpha) {
Alpha=alpha;
}
public void setMagnetRayExp(final String s) {
magnetRayExp=new Expression(s, Cn, this);
}
public String getMagnetRayExp() {
return magnetRayExp.toString();
}
public int getMagnetRay() {
int i=20;
try {
i=(int) Math.round(magnetRayExp.getValue());
} catch (final Exception ex) {
}
return i;
}
public boolean isMagnet() {
return (CurrentMagnetObject!=null);
}
private boolean isMagnetObject(final String name) {
final Enumeration e=magnetObjects.elements();
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
if (mo.name().equals(name)) {
return true;
}
}
return false;
}
public void removeMagnetObject(final String name) {
final Enumeration e=magnetObjects.elements();
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
if (mo.name().equals(name)) {
magnetObjects.remove(mo);
}
}
}
/**
* s represents the name of an object, or the string "name:ray" where ray is
* the specific magnetic attraction
*
* @param s
*/
public void addMagnetObject(final String s) {
final String[] mo=s.split(":");
final String name=mo[0];
// int ray=-1;
String ray=""+Integer.MIN_VALUE;
if (mo.length>1) {
ray=mo[1];
}
if (name.equals(getName())) {
return;
}
final ConstructionObject o=Cn.find(name);
if ((o!=null)&&(!isMagnetObject(name))) {
magnetObjects.add(new MagnetObj(o, ray));
}
}
public void setMagnetObjects(final String namelist) {
String st="";
char t;
int p=0;
for (int i=0; i<namelist.length(); i++) {
t=namelist.charAt(i);
if (t=='(') {
p++;
} else if (t==')') {
p--;
}
if ((p>0)&&(t==',')) {
st+="@@";
} else {
st+=t;
}
}
final String[] s=st.split(",");
magnetObjects.removeAllElements();
for (final String element : s) {
st=element.replaceAll("@@", ",");
addMagnetObject(st);
}
}
public void selectMagnetObjects(final boolean b) {
final Enumeration e=magnetObjects.elements();
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
if (mo.isInConstruction()) {
mo.setSelected(b);
}
}
}
public void updateMagnetObjects() {
final Enumeration e=magnetObjects.elements();
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
if (!mo.isInConstruction()) {
magnetObjects.remove(mo);
}
}
}
public void clearMagnetObjects() {
magnetObjects.removeAllElements();
setMagnetRayExp("20");
}
public void translateMagnetObjects() {
final Enumeration e=magnetObjects.elements();
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
mo.translate();
}
}
public Vector getMagnetObjects() {
return magnetObjects;
}
public String getMagnetObjectsString() {
updateMagnetObjects();
String s="";
final Enumeration e=magnetObjects.elements();
if (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
s=mo.name();
if (mo.ray()>Integer.MIN_VALUE) {
s+=":"+mo.rayexp();
}
}
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
s+=","+mo.name();
if (mo.ray()>Integer.MIN_VALUE) {
s+=":"+mo.rayexp();
}
}
return s;
}
public void magnet() {
ConstructionObject PtOnObject=null;
ConstructionObject PtObject=null;
final Enumeration e=magnetObjects.elements();
int dp=Integer.MAX_VALUE, dm=Integer.MAX_VALUE;
int rayp=0, raym=0;
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
final ConstructionObject o=mo.obj();
final int mRay=(mo.ray()>Integer.MIN_VALUE)?mo.ray()
:getMagnetRay();
final int mRayAbs=Math.abs(mRay);
if (mRayAbs==0) {
continue;
}
if (!o.valid()) {
continue;
}
if (o instanceof PointObject) {
final int i=o.getDistance(this);
if ((i<=mRayAbs)&&(i<dp)) {
PtObject=o;
rayp=mRay;
dp=i;
}
} else if (o instanceof PointonObject) {
final int i=o.getDistance(this);
if ((i<=mRayAbs)&&(i<dm)) {
PtOnObject=o;
raym=mRay;
dm=i;
}
}
}
if (PtObject!=null) {
final PointObject pt=(PointObject) PtObject;
setXYaway(pt.getX(), pt.getY(), rayp);
if (PtObject!=CurrentMagnetObject) {
CurrentMagnetObject=PtObject;
CurrentMagnetRay=rayp;
Cn.reorderConstruction();
}
pipe_tools.Magnet_To_HTML(this.getName(), CurrentMagnetObject.getName());
} else if (PtOnObject!=null) {
final PointonObject pt=(PointonObject) PtOnObject;
if (PtOnObject!=CurrentMagnetObject) {
CurrentMagnetObject=PtOnObject;
CurrentMagnetRay=raym;
Cn.reorderConstruction();
}
pt.project(this);
pipe_tools.Magnet_To_HTML(this.getName(), CurrentMagnetObject.getName());
} else {
CurrentMagnetObject=null;
CurrentMagnetRay=Integer.MIN_VALUE;
if (magnetObjects.size()>0) {
pipe_tools.Magnet_To_HTML(this.getName(), "");
}
}
}
public void setCurrentMagnetObject() {
ConstructionObject PtOnObject=null;
ConstructionObject PtObject=null;
final Enumeration e=magnetObjects.elements();
int dp=Integer.MAX_VALUE, dm=Integer.MAX_VALUE;
int rayp=0, raym=0;
while (e.hasMoreElements()) {
final MagnetObj mo=(MagnetObj) e.nextElement();
final ConstructionObject o=mo.obj();
final int mRay=(mo.ray()>Integer.MIN_VALUE)?mo.ray()
:getMagnetRay();
if (o instanceof PointObject) {
final int i=o.getDistance(this);
if ((i<=mRay)&&(i<dp)) {
PtObject=o;
rayp=mRay;
dp=i;
}
} else if (o instanceof PointonObject) {
final int i=o.getDistance(this);
if ((i<=mRay)&&(i<dm)) {
PtOnObject=o;
raym=mRay;
dm=i;
}
}
}
if (PtObject!=null) {
CurrentMagnetObject=PtObject;
CurrentMagnetRay=rayp;
} else if (PtOnObject!=null) {
CurrentMagnetObject=PtOnObject;
CurrentMagnetRay=raym;
} else {
CurrentMagnetObject=null;
CurrentMagnetRay=Integer.MIN_VALUE;
}
}
public ConstructionObject getCurrentMagnetObject() {
return CurrentMagnetObject;
}
public void followMagnetObject() {
if (CurrentMagnetObject!=null) {
if (CurrentMagnetObject instanceof PointObject) {
final PointObject pt=(PointObject) CurrentMagnetObject;
if (CurrentMagnetRay>0) {
setXY(pt.getX(), pt.getY());
}
} else if (CurrentMagnetObject instanceof PointonObject) {
project(CurrentMagnetObject, Alpha);
}
}
magnet();
}
@Override
public int getDistance(final PointObject P) {
final double d=Math.sqrt(((getX()-P.getX())*(getX()-P.getX())+(getY()-P.getY())*(getY()-P.getY())));
return (int) Math.round(d*Cn.getPixel());
}
public void project(final ConstructionObject o) {
if (!(o instanceof PointonObject)) {
return;
}
((PointonObject) o).project(this);
if (UseAlpha) {
AlphaValid=true;
}
}
public void project(final ConstructionObject o, final double alpha) {
((PointonObject) o).project(this, alpha);
}
@Override
public void printArgs(final XmlWriter xml) {
updateText();
updateMagnetObjects();
if (Bound!=null) {
xml.printArg("on", Bound.getName());
if (KeepInside) {
xml.printArg("inside", "true");
}
}
if (magnetObjects.size()>0) {
xml.printArg("magnetobjs", getMagnetObjectsString());
xml.printArg("magnetd", ""+magnetRayExp.toString());
}
if (haveBoundOrder()) {
xml.printArg("boundorder", String.valueOf(BoundOrder));
}
if (Fixed&&EX!=null) {
xml.printArg("x", EX.toString());
xml.printArg("actx", ""+X);
} else {
if (Bound!=null&&AlphaValid&&UseAlpha) {
xml.printArg("alpha", ""+Alpha);
}
xml.printArg("x", ""+X);
}
if (Fixed&&EY!=null) {
xml.printArg("y", EY.toString());
xml.printArg("acty", ""+Y);
} else {
xml.printArg("y", ""+Y);
}
printType(xml);
if (Is3D) {
xml.printArg("is3D", "true");
if (Fixed3D&&EX3D!=null) {
xml.printArg("x3D", EX3D.toString());
xml.printArg("actx3D", ""+X3D);
} else {
xml.printArg("x3D", ""+X3D);
}
if (Fixed3D&&EY3D!=null) {
xml.printArg("y3D", EY3D.toString());
xml.printArg("acty3D", ""+Y3D);
} else {
xml.printArg("y3D", ""+Y3D);
}
if (Fixed3D&&EZ3D!=null) {
xml.printArg("z3D", EZ3D.toString());
xml.printArg("actz3D", ""+Z3D);
} else {
xml.printArg("z3D", ""+Z3D);
}
}
if (Fixed) {
xml.printArg("fixed", "true");
}
if (Fixed3D) {
xml.printArg("fixed3D", "true");
}
if (Increment>1e-4) {
xml.printArg("increment", ""+getIncrement());
}
}
public void printType(final XmlWriter xml) {
if (Type!=0) {
switch (Type) {
case DIAMOND:
xml.printArg("shape", "diamond");
break;
case CIRCLE:
xml.printArg("shape", "circle");
break;
case DOT:
xml.printArg("shape", "dot");
break;
case CROSS:
xml.printArg("shape", "cross");
break;
case DCROSS:
xml.printArg("shape", "dcross");
break;
}
}
}
@Override
public int getType() {
return Type;
}
@Override
public void setType(final int type) {
Type=type;
}
public void movedBy(final ConstructionObject o) {
MovedBy=o;
}
@Override
public boolean equals(final ConstructionObject o) {
if (!(o instanceof PointObject)||!o.valid()) {
return false;
}
final PointObject p=(PointObject) o;
return equals(X, p.X)&&equals(Y, p.Y);
}
@Override
public String getEX() {
if (EX!=null) {
return EX.toString();
} else {
return ""+round(X);
}
}
@Override
public String getEY() {
if (EY!=null) {
return EY.toString();
} else {
return ""+round(Y);
}
}
@Override
public String getEX3D() {
if (EX3D!=null) {
return EX3D.toString();
} else {
return ""+round(X3D);
}
}
@Override
public String getEY3D() {
if (EY3D!=null) {
return EY3D.toString();
} else {
return ""+round(Y3D);
}
}
@Override
public String getEZ3D() {
if (EZ3D!=null) {
return EZ3D.toString();
} else {
return ""+round(Z3D);
}
}
public boolean isOn(final ConstructionObject o) {
if (Bound!=null) {
return o==Bound;
}
return o.contains(this);
}
@Override
public void translate() {
if (Bound!=null) {
Bound=Bound.getTranslation();
}
else if (Is3D&Fixed3D) {
try {
setFixed(EX3D.toString(), EY3D.toString(), EZ3D.toString());
EX3D.translate();
EY3D.translate();
EZ3D.translate();
}
catch (final Exception e) {}
}
else if (Fixed) {
try {
setFixed(EX.toString(), EY.toString());
EX.translate();
EY.translate();
} catch (final Exception e) {
}
}
magnetRayExp.translate();
translateMagnetObjects();
}
@Override
public Enumeration depending() {
super.depending();
if (Bound!=null) {
DL.add(Bound);
}
if (Fixed) {
if (EX!=null) {
EX.addDep(this);
}
if (EY!=null) {
EY.addDep(this);
}
}
if (Is3D&&Fixed3D) {
if (EX3D!=null) {
EX3D.addDep(this);
}
if (EY3D!=null) {
EY3D.addDep(this);
}
if (EZ3D!=null) {
EZ3D.addDep(this);
}
}
return DL.elements();
}
@Override
public void snap(final ZirkelCanvas zc) {
final double d=zc.getGridSize()/2;
X=Math.round(X/d)*d;
Y=Math.round(Y/d)*d;
updateText();
}
public void setHalfIncrement(final ZirkelCanvas zc) {
final double d=zc.getGridSize()/2;
setIncrement(d);
validate();
}
@Override
public void updateCircleDep() {
if (Bound!=null&&Bound instanceof PrimitiveCircleObject) {
((PrimitiveCircleObject) Bound).addDep(this);
}
if (Bound!=null&&Bound instanceof PrimitiveLineObject) {
((PrimitiveLineObject) Bound).addDep(this);
}
}
public boolean isPointOn() {
return Bound!=null;
}
public boolean isPointOnOrMagnet() {
return (Bound!=null)||(CurrentMagnetObject!=null);
}
public void setLaterBind(final String s) {
LaterBind=s;
}
// for macro constructions :
@Override
public ConstructionObject copy(final double x, final double y) {
ConstructionObject o=null;
try {
o=(ConstructionObject) clone();
setTranslation(o);
o.translateConditionals();
o.translate();
o.setName();
o.updateText();
o.setBreak(false);
// o.setTarget(false);
// if the target is a Point inside polygon, then try
// to follow the mouse ! :
if (KeepInside&&Bound!=null&&Bound instanceof AreaObject) {
o.move(x, y);
}
} catch (final Exception e) {
}
return o;
}
public void computeBarycentricCoords() {
if (Bound==null) {
return;
}
if (Bound instanceof QuadricObject) {
final QuadricObject quad=((QuadricObject) Bound);
final PointObject A=quad.P[0];
final PointObject B=quad.P[1];
final PointObject C=quad.P[2];
final double a=B.getX()-A.getX();
final double b=C.getX()-A.getX();
final double c=this.getX()-A.getX();
final double d=B.getY()-A.getY();
final double e=C.getY()-A.getY();
final double f=this.getY()-A.getY();
final double det=a*e-d*b;
if (det!=0) {
Gx=(c*e-b*f)/det;
Gy=(a*f-c*d)/det;
BarycentricCoordsInitialzed=true;
}
} else if (KeepInside&&Bound instanceof AreaObject) {
final AreaObject area=((AreaObject) Bound);
if (area.V.size()>2) {
final PointObject A=(PointObject) area.V.get(0);
final PointObject B=(PointObject) area.V.get(1);
final PointObject C=(PointObject) area.V.get(2);
final double a=B.getX()-A.getX();
final double b=C.getX()-A.getX();
final double c=this.getX()-A.getX();
final double d=B.getY()-A.getY();
final double e=C.getY()-A.getY();
final double f=this.getY()-A.getY();
final double det=a*e-d*b;
if (det!=0) {
Gx=(c*e-b*f)/det;
Gy=(a*f-c*d)/det;
BarycentricCoordsInitialzed=true;
}
}
}
}
@Override
public void setInside(final boolean flag) {
KeepInside=flag;
computeBarycentricCoords();
}
@Override
public boolean isInside() {
return KeepInside;
}
public boolean isFixedInWindow() {
String xstr="(windoww/(windoww-d(windoww)))*(x("+getName()+")-windowcx)+windowcx+d(windowcx)";
String ystr="(windoww/(windoww-d(windoww)))*(y("+getName()+")-windowcy)+windowcy+d(windowcy)";
if ((xstr.equals(getEX()))&&(ystr.equals(getEY()))) {
return true;
}
;
return false;
}
@Override
public void laterBind(final Construction c) {
if (LaterBind.equals("")) {
return;
}
final ConstructionObject o=c.find(LaterBind);
if (o!=null&&((o instanceof PointonObject)||(o instanceof InsideObject))) {
Bound=o;
updateText();
validate();
}
LaterBind="";
}
public void setAlpha(final double alpha) {
Alpha=alpha;
AlphaValid=true;
}
public void setUseAlpha(final boolean flag) {
UseAlpha=flag;
}
public boolean useAlpha() {
return UseAlpha;
}
public double getAlpha() {
return Alpha;
}
@Override
public void round() {
move(round(X, ZirkelCanvas.LengthsFactor), round(Y,
ZirkelCanvas.LengthsFactor));
}
/**
* For bounded points.
*/
@Override
public void setKeepClose(final double x, final double y) {
KeepClose=true;
XcOffset=x-X;
YcOffset=y-Y;
}
@Override
public boolean canKeepClose() {
return true;
}
public boolean dontUpdate() {
return DontUpdate;
}
public void dontUpdate(final boolean flag) {
DontUpdate=flag;
}
/**
* Overwrite setting of default things for macro targets.
*/
// public void setTargetDefaults ()
// { super.setTargetDefaults();
// Type=Cn.DefaultType;
// }
@Override
public void startDrag(final double x, final double y) {
}
@Override
public void dragTo(final double x, final double y) {
clearBoundOrder();
if ((X==x)&&(Y==y)) {
return;
}
// System.out.println(getName()+" : dragTo !");
move(x, y);
}
@Override
public double getOldX() {
return 0;
}
@Override
public double getOldY() {
return 0;
}
@Override
public void setIncrement(final double inc) {
Increment=inc;
}
@Override
public double getIncrement() {
return Increment;
}
@Override
public boolean isDriverObject() {
if (Bound!=null) {
return true;
}
// if (Fixed) return false;
return Moveable&&!Keep;
}
@Override
public boolean somethingChanged() {
return ((getX()!=LASTX)||(getY()!=LASTY));
}
@Override
public void clearChanges() {
LASTX=getX();
LASTY=getY();
}
public void setEX3D(String s) {
EX3D=new Expression(s, JZirkelCanvas.getCurrentZC().getConstruction(), this);
}
}
Reference in New Issue Copy Permalink