CaRMtl/rene/zirkel/objects/.#PointObject.java.1.6
2018-09-04 22:51:42 -04:00

1539 lines
45 KiB
Groff
Executable File

/*
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/>.
*/
package rene.zirkel.objects;
// file: PointObject.java
import java.awt.Button;
import java.awt.Checkbox;
import java.awt.Color;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.event.FocusEvent;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.JPanel;
import rene.dialogs.Warning;
import rene.gui.ButtonAction;
import rene.gui.CheckboxAction;
import rene.gui.Global;
import rene.gui.IconBar;
import rene.gui.MyLabel;
import rene.gui.MyPanel;
import rene.gui.MyTextField;
import rene.gui.TextFieldAction;
import rene.util.xml.XmlWriter;
import rene.zirkel.Zirkel;
import rene.zirkel.ZirkelCanvas;
import rene.zirkel.construction.Construction;
import rene.zirkel.dialogs.EditConditionals;
import rene.zirkel.dialogs.ObjectEditDialog;
import rene.zirkel.expression.Expression;
import rene.zirkel.graphics.MyGraphics;
import rene.zirkel.graphics.MyGraphics13;
import rene.zirkel.structures.MagnetObj;
import eric.JGlobals;
import eric.JPointName;
class PointEditDialog extends ObjectEditDialog {
/**
*
*/
private static final long serialVersionUID=1L;
TextFieldAction X, Y;
MyTextField Away, Bound, Increment;
Checkbox Fixed, Close, Restricted, Alternate, Inside;
IconBar TypeIB;
ZirkelCanvas ZC;
public PointEditDialog(final Frame f, final PointObject o) {
super(f, Zirkel.name("edit.point.title"), o);
}
public PointEditDialog(final ZirkelCanvas zc, final PointObject o) {
this(zc.getFrame(), o);
ZC=zc;
}
@Override
public void addFirst(final JPanel P) {
final PointObject p=(PointObject) O;
X=new TextFieldAction(this, "X", ""+p.round(p.getX()), 30);
P.add(new MyLabel(Zirkel.name("edit.point.x")));
P.add(X);
Y=new TextFieldAction(this, "Y", ""+p.round(p.getY()), 30);
P.add(new MyLabel(Zirkel.name("edit.point.y")));
P.add(Y);
if (p.moveablePoint()) {
Fixed=new Checkbox("");
Fixed.setState(p.fixed());
P.add(new MyLabel(Zirkel.name("edit.fixed")));
P.add(Fixed);
if (p.fixed()) {
X.setText(p.getEX());
Y.setText(p.getEY());
}
P.add(new MyLabel(Zirkel.name("edit.point.increment")));
P.add(Increment=new MyTextField(""+p.round(p.getIncrement())));
} else {
X.setEditable(false);
Y.setEditable(false);
}
if ((p instanceof IntersectionObject&&((IntersectionObject) p).isSwitchable())) {
Away=new MyTextField("", 5);
Away.setText(((IntersectionObject) p).away());
Close=new CheckboxAction(this, Zirkel.name("edit.point.close"));
Close.setState(!((IntersectionObject) p).stayAway());
P.add(new MyLabel(Zirkel.name("edit.point.intersection")));
final JPanel ap=new MyPanel();
ap.setLayout(new GridLayout(1, 2));
ap.add(Away);
ap.add(Close);
P.add(ap);
}
if (p instanceof IntersectionObject) {
P.add(new MyLabel(Zirkel.name("edit.plumb.restricted")));
Restricted=new CheckboxAction(this, "", "Restricted");
Restricted.setState(((IntersectionObject) p).isRestricted());
P.add(Restricted);
if (((IntersectionObject) p).canAlternate()) {
P.add(new MyLabel(Zirkel.name("edit.intersection.alternate")));
Alternate=new CheckboxAction(this, "", "Alternate");
Alternate.setState(((IntersectionObject) p).isAlternate());
P.add(Alternate);
}
}
if (p.isPointOn()) {
P.add(new MyLabel(Zirkel.name("edit.point.bound")));
P.add(Bound=new MyTextField(p.getBound().getName()));
Bound.setEditable(false);
if (p.getBound() instanceof InsideObject) {
P.add(new MyLabel(Zirkel.name("edit.point.inside")));
P.add(Inside=new CheckboxAction(this, "", "Inside"));
Inside.setState(p.isInside());
}
if (Fixed!=null) {
Fixed.setState(p.useAlpha());
}
}
}
Button BoundButton;
@Override
public void addButton(final JPanel P) {
final PointObject p=(PointObject) O;
if (p.moveablePoint()) {
if (p.isPointOn()) {
BoundButton=new ButtonAction(this, Zirkel.name("bound.release"), "Release");
} else {
BoundButton=new ButtonAction(this, Zirkel.name("bound.bind"),
"Bind");
}
P.add(BoundButton);
P.add(new MyLabel(" "));
} else if (p instanceof IntersectionObject&&((IntersectionObject) p).isSwitchable()) {
P.add(new ButtonAction(this, Zirkel.name("edit.point.away"),
"SetAway"));
P.add(new ButtonAction(this, Zirkel.name("edit.point.close"),
"SetClose"));
if (!((IntersectionObject) p).away().equals("")) {
P.add(new ButtonAction(this, Zirkel.name("edit.point.free"),
"SetFree"));
}
P.add(new MyLabel(" "));
}
}
@Override
public void addSecond(final JPanel P) {
final PointObject p=(PointObject) O;
TypeIB=new IconBar(F);
TypeIB.addToggleGroupLeft("type", 6);
TypeIB.toggle("type", p.getType());
P.add(new MyLabel(""));
P.add(TypeIB);
}
@Override
public void doAction(final String o) {
if ((o.equals("Y")||o.equals("X"))&&Fixed!=null) {
Fixed.setState(true);
super.doAction("OK");
} else if (o.equals("Release")) {
((PointObject) O).setBound("");
O.getConstruction().updateCircleDep();
if (Fixed!=null) {
Fixed.setState(false);
}
super.doAction("OK");
} else if (o.equals("Bind")) {
ZC.bind((PointObject) O);
super.doAction("OK");
} else if (o.equals("SetAway")) {
ZC.setAway((IntersectionObject) O, true);
super.doAction("OK");
} else if (o.equals("SetClose")) {
ZC.setAway((IntersectionObject) O, false);
super.doAction("OK");
} else if (o.equals("SetFree")) {
((IntersectionObject) O).setAway("");
Away=null;
super.doAction("OK");
} else if (o.equals("OK")) {
if (Fixed!=null&&X.isChanged()||Y.isChanged()) {
Fixed.setState(true);
}
super.doAction("OK");
} else {
super.doAction(o);
}
}
@Override
public void setAction() {
final PointObject p=(PointObject) O;
if ((X.isChanged()||Y.isChanged())&&p.isPointOn()) {
try {
final double x=new Expression(X.getText(), p.getConstruction(), p).getValue();
final double y=new Expression(Y.getText(), p.getConstruction(), p).getValue();
p.move(x, y);
p.validate();
} catch (final Exception e) {
}
}
if (Fixed!=null&&Fixed.getState()==true) {
if (p.isPointOn()) {
p.setUseAlpha(true);
} else {
p.setFixed(X.getText(), Y.getText());
}
} else {
try {
final double x=new Expression(X.getText(), p.getConstruction(), p).getValue();
final double y=new Expression(Y.getText(), p.getConstruction(), p).getValue();
if (p.moveable()) {
p.move(x, y);
}
} catch (final Exception e) {
}
}
if (Fixed!=null&&Fixed.getState()==false) {
if (p.isPointOn()) {
p.setUseAlpha(false);
} else {
p.setFixed(false);
}
}
if (Away!=null) {
if (!((IntersectionObject) p).setAway(Away.getText(), !Close.getState())) {
final Warning w=new Warning(F, Zirkel.name("bound.error"),
Zirkel.name("warning"));
w.center(F);
w.setVisible(true);
}
}
if (Restricted!=null) {
((IntersectionObject) p).setRestricted(Restricted.getState());
}
if (Alternate!=null) {
((IntersectionObject) p).setAlternate(Alternate.getState());
}
if (Increment!=null) {
try {
p.setIncrement(new Expression(Increment.getText(), p.getConstruction(), p).getValue());
} catch (final Exception e) {
}
}
p.setType(TypeIB.getToggleState("type"));
if (Inside!=null) {
p.setInside(Inside.getState());
}
}
@Override
public void focusGained(final FocusEvent e) {
if (Fixed!=null&&Fixed.getState()) {
X.requestFocus();
} else {
super.focusGained(e);
}
}
}
public class PointObject extends ConstructionObject implements MoveableObject,
DriverObject {
protected double X, Y;
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;
// private static Count N=new Count();
private static JPointName PointLabel=new JPointName();
protected int Type=0;
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;
// 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;
Moveable=true;
Fixed=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;
}
public PointObject(final Construction c, final String name) {
super(c, name);
X=0;
Y=0;
Moveable=true;
Fixed=false;
setColor(ColorIndex, SpecialColor);
updateText();
Type=0;
setMagnetRayExp("20");
}
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", (Color) null));
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", (Color) null));
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
public void validate() {
if (DontUpdate) {
return;
}
// System.out.println(getName()+" X="+X+" Y="+Y);
updateMagnetObjects();
followMagnetObject();
// magnet();
// System.out.println(getName()+" : validate !");
MovedBy=null;
Delta=0.0;
Valid=true;
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 (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;
}
}
}
@Override
public void updateText() {
if (Bound!=null) {
setText(text1(Zirkel.name("text.boundedpoint"), Bound.getName()));
} else if (EX!=null&&EY!=null) {
setText(text2(Zirkel.name("text.point"), "\""+EX+"\"", "\""+EY+"\""));
} else {
setText(text2(Zirkel.name("text.point"), ""+round(X), ""+round(Y)));
}
}
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);
if (size<1) {
size=1;
}
// System.out.println(size);
if (o.visible(zc)) {
if (o.isStrongSelected()&&g instanceof MyGraphics13) {
((MyGraphics13) g).drawMarkerLine(r, c, r, c);
}
g.setColor(o);
switch (type) {
case SQUARE:
final double sx=r-size-1,
sy=c-size-1,
sw=2*size+2;
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-2,
dy=c-size-2,
dw=2*size+4;
g.drawDiamond(dx, dy, dw, (o.getColorType()==THICK), o);
break;
case CIRCLE:
final double cx=r-size-1,
cy=c-size-1,
cw=2*size+2;
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, 1, 1, true, false, o);
} else {
g.drawLine(r, c, r, c);
}
break;
case CROSS:
if (o.getColorType()==THICK) {
g.drawThickLine(r-size, c, r+size, c);
g.drawThickLine(r, c-size, r, c+size);
} else {
g.drawLine(r-size, c, r+size, c);
g.drawLine(r, c-size, r, c+size);
}
break;
case DCROSS:
final double dcx=r-size-1,
dcy=c-size-1,
dcw=2*size+1;
g.drawDcross(dcx, dcy, dcw, (o.getColorType()==THICK), o);
break;
}
}
return size;
}
@Override
public String getDisplayValue() {
// return "("+roundDisplay(X)+
// (Global.getParameter("options.germanpoints",
// false)?"|":",")+roundDisplay(Y)+")";
return "("+JGlobals.getLocaleNumber(X, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
:";")+JGlobals.getLocaleNumber(Y, "lengths")+")";
}
@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) {
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;
}
public boolean moveable() {
boolean fixed=Fixed;
if (dependsOnItselfOnly()) {
fixed=false;
}
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);
Later=false;
return true;
}
try {
Bound=null;
final ConstructionObject o=Cn.find(name);
if (o instanceof PointonObject) {
Bound=o;
Moveable=true;
Fixed=false;
KeepInside=false;
} else if (o instanceof InsideObject) {
Bound=o;
Moveable=true;
Fixed=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();
}
@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 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();
}
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 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 String getMagnetRayExp(){
// return magnetRayExp.toString();
// }
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();
}
} else if (PtOnObject!=null) {
final PointonObject pt=(PointonObject) PtOnObject;
if (PtOnObject!=CurrentMagnetObject) {
CurrentMagnetObject=PtOnObject;
CurrentMagnetRay=raym;
Cn.reorderConstruction();
}
pt.project(this);
} else {
CurrentMagnetObject=null;
CurrentMagnetRay=Integer.MIN_VALUE;
}
}
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>Integer.MIN_VALUE) {
setXYaway(pt.getX(), pt.getY(), CurrentMagnetRay);
}
} else if (CurrentMagnetObject instanceof PointonObject) {
final PointonObject pt=(PointonObject) CurrentMagnetObject;
pt.project(this);
}
}
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 edit(final ZirkelCanvas zc) {
if (!rene.zirkel.Zirkel.IsApplet) {
eric.JGlobals.EditObject(this);
return;
}
final ObjectEditDialog d=new PointEditDialog(zc, this);
d.setVisible(true);
zc.repaint();
if ((EX!=null&&!EX.isValid())) {
final Frame F=zc.getFrame();
final Warning w=new Warning(F, EX.getErrorText(), Zirkel.name("warning"), true);
w.center(F);
w.setVisible(true);
} else if ((EY!=null&&!EY.isValid())) {
final Frame F=zc.getFrame();
final Warning w=new Warning(F, EY.getErrorText(), Zirkel.name("warning"), true);
w.center(F);
w.setVisible(true);
}
validate();
if (d.wantsMore()) {
new EditConditionals(zc.getFrame(), this);
validate();
}
}
@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 (Fixed) {
xml.printArg("fixed", "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);
}
}
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 (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);
}
}
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();
}
@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&&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!=null&&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;
}
@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;
// }
public void startDrag(final double x, final double y) {
}
public void dragTo(final double x, final double y) {
clearBoundOrder();
if ((X==x)&&(Y==y)) {
return;
}
// System.out.println(getName()+" : dragTo !");
move(x, y);
}
public double getOldX() {
return 0;
}
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;
}
public boolean somethingChanged() {
return ((getX()!=LASTX)||(getY()!=LASTY));
}
public void clearChanges() {
LASTX=getX();
LASTY=getY();
}
}