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

1016 lines
37 KiB
Java

/*
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: Circle3Object.java
import eric.bar.JPropertiesBar;
import java.awt.Checkbox;
import java.awt.Color;
import java.awt.Frame;
import java.awt.TextField;
import java.awt.event.FocusEvent;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
import eric.JEricPanel;
import rene.dialogs.Warning;
import rene.gui.Global;
import rene.gui.IconBar;
import rene.gui.IconBarListener;
import rene.gui.MyLabel;
import rene.gui.TextFieldAction;
import rene.util.xml.XmlWriter;
import rene.gui.Global;
import rene.zirkel.ZirkelCanvas;
import rene.zirkel.construction.Construction;
import rene.zirkel.construction.ConstructionException;
import rene.zirkel.construction.Count;
import rene.zirkel.expression.Expression;
import rene.zirkel.expression.ExpressionColor;
import rene.zirkel.expression.InvalidException;
import rene.zirkel.graphics.MyGraphics;
import rene.zirkel.graphics.MainGraphics;
import rene.zirkel.graphics.PolygonDrawer;
public class AngleObject extends ConstructionObject implements InsideObject {
protected PointObject P1, P2, P3;
static Count N=new Count();
double A, A1, A2, A3D; // Dibs : A3D est l'angle 3D
double X, Y;
boolean Fixed;
Expression E;
boolean Filled=false;
final static double LabelScale=0.66;
public static final int NORMALSIZE=1, SMALL=0, LARGER=2, LARGE=3,
RECT=4;
protected int DisplaySize=NORMALSIZE;
public AngleObject(final Construction c, final PointObject p1,
final PointObject p2, final PointObject p3) {
super(c);
P1=p1;
P2=p2;
P3=p3;
validate();
setColor(ColorIndex, SpecialColor);
updateText();
Unit=Global.getParameter("unit.angle", "°");
double xx=P1.getX()+P3.getX()-2*P2.getX();
double yy=P1.getY()+P3.getY()-2*P2.getY();
final double ll=Math.max(Math.sqrt(xx*xx+yy*yy),0.000001);
xx=xx/ll;
yy=yy/ll;
XcOffset=xx*25/c.getPixel();
YcOffset=yy*25/c.getPixel();
}
public AngleObject(final Construction c) {
super(c);
}
@Override
public void setDefaults() {
setShowName(Global.getParameter("options.angle.shownames", false));
setShowValue(Global.getParameter("options.angle.showvalues", false));
setColor(Global.getParameter("options.angle.color", 0), Global.getParameter("options.angle.pcolor", (ExpressionColor) null, this));
setColorType(Global.getParameter("options.angle.colortype", 0));
setFilled(Global.getParameter("options.angle.filled", false));
setHidden(Cn.Hidden);
setObtuse(Global.getParameter("options.angle.obtuse", false));
setSolid(Global.getParameter("options.angle.solid", false));
setLarge(Cn.LargeFont);
setBold(Cn.BoldFont);
setPartial(Cn.Partial);
}
@Override
public void setTargetDefaults() {
setShowName(Global.getParameter("options.angle.shownames", false));
setShowValue(Global.getParameter("options.angle.showvalues", false));
setColor(Global.getParameter("options.angle.color", 0), Global.getParameter("options.angle.pcolor", (ExpressionColor) null, this));
setColorType(Global.getParameter("options.angle.colortype", 0));
setFilled(Global.getParameter("options.angle.filled", false));
setObtuse(Global.getParameter("options.angle.obtuse", false));
setSolid(Global.getParameter("options.angle.solid", false));
}
@Override
public String getTag() {
return "Angle";
}
@Override
public int getN() {
return N.next();
}
@Override
public void updateText() {
if (!Fixed||E==null) {
setText(text3(Global.name("text.angle"), P1.getName(),
P2.getName(), P3.getName()));
} else {
setText(text4(Global.name("text.angle.fixed"), P1.getName(), P2.getName(), P3.getName(), "\""+E.toString()+"\""));
}
}
@Override
public String getDisplayValue() {
// if (ZirkelCanvas.AnglesFactor<=2) {
// return ""+(int) (A/Math.PI*180+0.5);
// } else {
// return ""+round(A/Math.PI*180, ZirkelCanvas.AnglesFactor);
// }
if (P1.is3D()&&P2.is3D()&&P3.is3D()) return Global.getLocaleNumber(A3D/Math.PI*180, "angles");
else return Global.getLocaleNumber(A/Math.PI*180, "angles");
}
@Override
public boolean nearto(final int x, final int y, final ZirkelCanvas zc) {
if (!displays(zc)) {
return false;
}
final double dx=zc.x(x)-X, dy=zc.y(y)-Y;
final double size=zc.dx(zc.selectionSize());
final double rd=getDisplaySize(zc), r=Math.sqrt(dx*dx+dy*dy);
boolean near;
Value=Math.abs(r-rd);
if (Filled||DisplaySize==RECT) {
near=(r<rd+size);
if (near) {
Value=0;
}
} else {
near=(Math.abs(r-rd)<size);
}
if (!near) {
return false;
}
if (rd<size) {
return near;
}
double a=Math.atan2(dy, dx);
if (a<0) {
a+=2*Math.PI;
}
final double c=0.05;
if (a<A1) {
a+=2*Math.PI;
}
return a>A1-c&&a<A1+A+c;
}
@Override
public void validate() {
if (P1==null) {
return;
}
if (!P1.valid()||!P2.valid()||!P3.valid()) {
Valid=false;
return;
} else {
X=P2.getX();
Y=P2.getY();
double dx=P1.getX()-X, dy=P1.getY()-Y;
if (Math.sqrt(dx*dx+dy*dy)<1e-9) {
Valid=false;
return;
}
A1=Math.atan2(dy, dx);
if (A1<0) {
A1+=2*Math.PI;
}
dx=P3.getX()-X;
dy=P3.getY()-Y;
if (Math.sqrt(dx*dx+dy*dy)<1e-9) {
Valid=false;
return;
}
A2=Math.atan2(dy, dx);
if (A2<0) {
A2+=2*Math.PI;
}
A=A2-A1;
if (A<0) {
A=A+2*Math.PI;
}
if (P1.is3D()&&P2.is3D()&&P3.is3D()) {
double dx13D=P1.getX3D()-P2.getX3D(), dy13D=P1.getY3D()-P2.getY3D(), dz13D=P1.getZ3D()-P2.getZ3D();
double dx23D=P3.getX3D()-P2.getX3D(), dy23D=P3.getY3D()-P2.getY3D(), dz23D=P3.getZ3D()-P2.getZ3D();
double n1=Math.sqrt(dx13D*dx13D+dy13D*dy13D+dz13D*dz13D);
double n2=Math.sqrt(dx23D*dx23D+dy23D*dy23D+dz23D*dz23D);
if (n1<1e-9||n2<1e-9) {
Valid=false;
return;
}
double pscal=dx13D*dx23D+dy13D*dy23D+dz13D*dz23D;
A3D=Math.acos(pscal/n1/n2);
}
Valid=true;
if (Fixed) {
double FixedAlpha=0;
try {
FixedAlpha=E.getValue()/180*Math.PI;
} catch (final Exception e) {
return;
}
if (P3.moveableBy(this)) {
dx=P3.getX()-X;
dy=P3.getY()-Y;
double r=Math.sqrt(dx*dx+dy*dy);
if (r<1e-9) {
r=1e-9;
}
P3.move(X+Math.cos(A1+FixedAlpha)*r, Y+Math.sin(A1+FixedAlpha)*r);
A2=A1+FixedAlpha;
} else {
Fixed=false;
}
if (Fixed) {
A=FixedAlpha;
P3.movedBy(this);
P1.movedBy(this);
}
} else if (!Obtuse&&A>Math.PI) {
A1=A2;
A=2*Math.PI-A;
A2=A1+A;
}
}
}
double x[]=new double[4], y[]=new double[4];
double x3D[]= new double[4], y3D[]= new double[4], z3D[]= new double[4];
double xx3D, yy3D, zz3D;
double xx, yy, zz;
@Override
public void paint(final MyGraphics g, final ZirkelCanvas zc) {
if (zc.is3D()&&P1.is3D()&&P2.is3D()&&P3.is3D()) { // angle 3D
//final double xx1=P1.getX()-P2.getX();
//final double yy1=P1.getY()-P2.getY();
//final double xx2=P3.getX()-P2.getX();
//final double yy2=P3.getY()-P2.getY();
double xx3D1=P1.getX3D()-P2.getX3D();
double yy3D1=P1.getY3D()-P2.getY3D();
double zz3D1=P1.getZ3D()-P2.getZ3D();
double d3D1=Math.sqrt(xx3D1*xx3D1+yy3D1*yy3D1+zz3D1*zz3D1);
double xx3D2=P3.getX3D()-P2.getX3D();
double yy3D2=P3.getY3D()-P2.getY3D();
double zz3D2=P3.getZ3D()-P2.getZ3D();
double d3D2=Math.sqrt(xx3D2*xx3D2+yy3D2*yy3D2+zz3D2*zz3D2);
xx3D1/=d3D1; // on normalise
yy3D1/=d3D1;
zz3D1/=d3D1;
xx3D2/=d3D2;
yy3D2/=d3D2;
zz3D2/=d3D2;
final double x3DP2=P2.getX3D();
final double y3DP2=P2.getY3D();
final double z3DP2=P2.getZ3D();
final double xO=zc.getConstruction().find("O").getX();
final double yO=zc.getConstruction().find("O").getY();
final double deltaxX=zc.getConstruction().find("X").getX()-xO;
final double deltaxY=zc.getConstruction().find("Y").getX()-xO;
final double deltaxZ=zc.getConstruction().find("Z").getX()-xO;
final double deltayX=zc.getConstruction().find("X").getY()-yO;
final double deltayY=zc.getConstruction().find("Y").getY()-yO;
final double deltayZ=zc.getConstruction().find("Z").getY()-yO;
double R3D=getDisplaySize(zc);
if (!Valid||mustHide(zc)) {
return;
}
final double R=zc.col(getDisplaySize(zc))-zc.col(0);
final double c1=zc.col(X)-R, r1=zc.row(Y)-R;
// paint:
double DA=(A2-A1)/Math.PI*180;
if (DA<0) {
DA+=360;
} else if (DA>=360) {
DA-=360;
}
if (visible(zc)) {
if (isStrongSelected()&&g instanceof MainGraphics) {
((MainGraphics) g).drawMarkerArc(c1+R, r1+R, R, A1/Math.PI*180, DA);
}
if (Filled) {
if (DisplaySize==RECT) { // Dibs : sert à rien ?
final double dx1=Math.cos(A1), dy1=Math.sin(A1), dx2=Math.cos(A1+DA/180*Math.PI), dy2=Math.sin(A1+DA/180*Math.PI);
double dx3=dx1+dx2, dy3=dy1+dy2;
if (DA>180) {
dx3=-dx3;
dy3=-dy3;
}
if (Selected||getColorType()!=THIN) {
g.setColor(this);
g.drawLine(c1+R+R*dx1, r1+R-R*dy1, c1+R+R*dx3, r1+R-R*dy3);
g.drawLine(c1+R+R*dx3, r1+R-R*dy3, c1+R+R*dx2, r1+R-R*dy2);
}
x[0]=c1+R;
y[0]=r1+R;
x[1]=c1+R+R*dx1;
y[1]=r1+R-R*dy1;
x[2]=c1+R+R*dx3;
y[2]=r1+R-R*dy3;
x[3]=c1+R+R*dx2;
y[3]=r1+R-R*dy2;
g.fillPolygon(x, y, 4, false,
getColorType()!=THICK, this);
} else { // angle 3D rempli
if (Math.abs(A3D-Math.PI/2)<0.00002) { // angle 3D droit
try {
R3D/=1.4;
x3D[0]=x3DP2;
y3D[0]=y3DP2;
z3D[0]=z3DP2;
x3D[1]=x3DP2+R3D*xx3D1;
y3D[1]=y3DP2+R3D*yy3D1;
z3D[1]=z3DP2+R3D*zz3D1;
x3D[2]=x3DP2+R3D*(xx3D1+xx3D2);
y3D[2]=y3DP2+R3D*(yy3D1+yy3D2);
z3D[2]=z3DP2+R3D*(zz3D1+zz3D2);
x3D[3]=x3DP2+R3D*xx3D2;
y3D[3]=y3DP2+R3D*yy3D2;
z3D[3]=z3DP2+R3D*zz3D2;
x[0]=xO+x3D[0]*deltaxX+y3D[0]*deltaxY+z3D[0]*deltaxZ;
y[0]=yO+x3D[0]*deltayX+y3D[0]*deltayY+z3D[0]*deltayZ;
x[1]=xO+x3D[1]*deltaxX+y3D[1]*deltaxY+z3D[1]*deltaxZ;
y[1]=yO+x3D[1]*deltayX+y3D[1]*deltayY+z3D[1]*deltayZ;
x[2]=xO+x3D[2]*deltaxX+y3D[2]*deltaxY+z3D[2]*deltaxZ;
y[2]=yO+x3D[2]*deltayX+y3D[2]*deltayY+z3D[2]*deltayZ;
x[3]=xO+x3D[3]*deltaxX+y3D[3]*deltaxY+z3D[3]*deltaxZ;
y[3]=yO+x3D[3]*deltayX+y3D[3]*deltayY+z3D[3]*deltayZ;
x[0]=zc.col(x[0]); y[0]=zc.row(y[0]);
x[1]=zc.col(x[1]); y[1]=zc.row(y[1]);
x[2]=zc.col(x[2]); y[2]=zc.row(y[2]);
x[3]=zc.col(x[3]); y[3]=zc.row(y[3]);
} catch (final Exception e) {
System.out.println("exception angle");
}
g.fillPolygon(x, y, 4, false, getColorType()!=THICK,
this);
g.setColor(this);
g.drawLine(x[1], y[1], x[2], y[2]);
g.drawLine(x[2], y[2], x[3], y[3]);
}
else { // pas droit
g.setColor(this);
final PolygonDrawer pd=new PolygonDrawer(true,g, this);
final double h=zc.dx(zc.getOne());
double pvectx1=yy3D1*zz3D2-zz3D1*yy3D2; // Objectif : obtenir le "bon vecteur normal" à P2P1
double pvecty1=zz3D1*xx3D2-xx3D1*zz3D2;
double pvectz1=xx3D1*yy3D2-yy3D1*xx3D2;
//final double norme1=Math.sqrt(pvectx1*pvectx1+pvecty1*pvecty1+pvectz1*pvectz1);
//pvectx1/=norme1; pvecty1/=norme1; pvectz1/=norme1;
double pvectx2=pvecty1*zz3D1-pvectz1*yy3D1;
double pvecty2=pvectz1*xx3D1-pvectx1*zz3D1;
double pvectz2=pvectx1*yy3D1-pvecty1*xx3D1;
final double norme2=Math.sqrt(pvectx2*pvectx2+pvecty2*pvecty2+pvectz2*pvectz2);
pvectx2/=norme2; pvecty2/=norme2; pvectz2/=norme2;
//final double ux=xx3D1/d3D1, uy=yy3D1/d3D1, uz=zz3D1/d3D1;
double alpha=0;
boolean valid=false;
int compteur=0;
ArrayList<Double> cx= new ArrayList<Double>(), cy=new ArrayList<Double>();
cx.add(0.0); cy.add(0.0); //juste pour coordonner des indices
while (alpha<=A3D) {
try {
xx3D=x3DP2+R3D*(Math.cos(alpha)*xx3D1+Math.sin(alpha)*pvectx2);
yy3D=y3DP2+R3D*(Math.cos(alpha)*yy3D1+Math.sin(alpha)*pvecty2);
zz3D=z3DP2+R3D*(Math.cos(alpha)*zz3D1+Math.sin(alpha)*pvectz2);
xx=xO+xx3D*deltaxX+yy3D*deltaxY+zz3D*deltaxZ;
yy=yO+xx3D*deltayX+yy3D*deltayY+zz3D*deltayZ;
final double c=zc.col(xx), r=zc.row(yy);
cx.add(c); cy.add(r);
if (valid) {
pd.drawTo(c, r);
compteur++;
} else {
pd.startPolygon(c, r);
}
valid=true;
} catch (final RuntimeException e) {
System.out.println("runtime exception");
valid=false;
}
alpha+=h;
}
pd.finishPolygon();
final double ccx[]= new double[compteur+2], ccy[]= new double[compteur+2];
ccx[0]=zc.col(xO+x3DP2*deltaxX+y3DP2*deltaxY+z3DP2*deltaxZ);
ccy[0]=zc.row(yO+x3DP2*deltayX+y3DP2*deltayY+z3DP2*deltayZ);
for (int i=1; i<compteur+2; i++) {
ccx[i]= cx.get(i);ccy[i]= cy.get(i);
}
g.fillPolygon(ccx, ccy, compteur+2, false, getColorType()!=THICK,
this);
}
// fin bloc pas droit
}
} else { // 3D pas rempli
g.setColor(this);
if (DisplaySize==RECT) {
final double dx1=Math.cos(A1), dy1=Math.sin(A1), dx2=Math.cos(A1+DA/180*Math.PI), dy2=Math.sin(A1+DA/180*Math.PI);
g.drawLine(c1+R+R*dx1, r1+R-R*dy1, c1+R+R*(dx1+dx2), r1+R-R*(dy1+dy2));
g.drawLine(c1+R+R*(dx1+dx2), r1+R-R*(dy1+dy2), c1+R+R*dx2, r1+R-R*dy2);
} else {
if (Math.abs(A3D-Math.PI/2)<0.00002) {
try {
R3D/=1.4;
x3D[0]=x3DP2;
y3D[0]=y3DP2;
z3D[0]=z3DP2;
x3D[1]=x3DP2+R3D*xx3D1;
y3D[1]=y3DP2+R3D*yy3D1;
z3D[1]=z3DP2+R3D*zz3D1;
x3D[2]=x3DP2+R3D*(xx3D1+xx3D2);
y3D[2]=y3DP2+R3D*(yy3D1+yy3D2);
z3D[2]=z3DP2+R3D*(zz3D1+zz3D2);
x3D[3]=x3DP2+R3D*xx3D2;
y3D[3]=y3DP2+R3D*yy3D2;
z3D[3]=z3DP2+R3D*zz3D2;
x[0]=xO+x3D[0]*deltaxX+y3D[0]*deltaxY+z3D[0]*deltaxZ;
y[0]=yO+x3D[0]*deltayX+y3D[0]*deltayY+z3D[0]*deltayZ;
x[1]=xO+x3D[1]*deltaxX+y3D[1]*deltaxY+z3D[1]*deltaxZ;
y[1]=yO+x3D[1]*deltayX+y3D[1]*deltayY+z3D[1]*deltayZ;
x[2]=xO+x3D[2]*deltaxX+y3D[2]*deltaxY+z3D[2]*deltaxZ;
y[2]=yO+x3D[2]*deltayX+y3D[2]*deltayY+z3D[2]*deltayZ;
x[3]=xO+x3D[3]*deltaxX+y3D[3]*deltaxY+z3D[3]*deltaxZ;
y[3]=yO+x3D[3]*deltayX+y3D[3]*deltayY+z3D[3]*deltayZ;
x[0]=zc.col(x[0]); y[0]=zc.row(y[0]);
x[1]=zc.col(x[1]); y[1]=zc.row(y[1]);
x[2]=zc.col(x[2]); y[2]=zc.row(y[2]);
x[3]=zc.col(x[3]); y[3]=zc.row(y[3]);
} catch (final Exception e) {
System.out.println("exception angle");
}
//g.setColor(this);
g.drawLine(x[1], y[1], x[2], y[2]);
g.drawLine(x[2], y[2], x[3], y[3]);
} else {
final PolygonDrawer pd=new PolygonDrawer(true,g, this);
final double h=zc.dx(zc.getOne());
double pvectx1=yy3D1*zz3D2-zz3D1*yy3D2; // Objectif : obtenir le "bon vecteur normal" à P2P1
double pvecty1=zz3D1*xx3D2-xx3D1*zz3D2;
double pvectz1=xx3D1*yy3D2-yy3D1*xx3D2;
//final double norme1=Math.sqrt(pvectx1*pvectx1+pvecty1*pvecty1+pvectz1*pvectz1);
//pvectx1/=norme1; pvecty1/=norme1; pvectz1/=norme1;
double pvectx2=pvecty1*zz3D1-pvectz1*yy3D1;
double pvecty2=pvectz1*xx3D1-pvectx1*zz3D1;
double pvectz2=pvectx1*yy3D1-pvecty1*xx3D1;
final double norme2=Math.sqrt(pvectx2*pvectx2+pvecty2*pvecty2+pvectz2*pvectz2);
pvectx2/=norme2; pvecty2/=norme2; pvectz2/=norme2;
//final double ux=xx3D1/d3D1, uy=yy3D1/d3D1, uz=zz3D1/d3D1;
double alpha=0;
boolean valid=false;
while (alpha<=A3D) {
try {
xx3D=x3DP2+R3D*(Math.cos(alpha)*xx3D1+Math.sin(alpha)*pvectx2);
yy3D=y3DP2+R3D*(Math.cos(alpha)*yy3D1+Math.sin(alpha)*pvecty2);
zz3D=z3DP2+R3D*(Math.cos(alpha)*zz3D1+Math.sin(alpha)*pvectz2);
xx=xO+xx3D*deltaxX+yy3D*deltaxY+zz3D*deltaxZ;
yy=yO+xx3D*deltayX+yy3D*deltayY+zz3D*deltayZ;
final double c=zc.col(xx), r=zc.row(yy);
if (valid) {
pd.drawTo(c, r);
} else {
pd.startPolygon(c, r);
}
valid=true;
} catch (final RuntimeException e) {
System.out.println("runtime exception");
valid=false;
}
alpha+=h;
}
pd.finishPolygon();
//g.setColor(this);
}
}
}
}
final String s=translateToUnicode(getDisplayText());
if (!s.equals("")) {
g.setLabelColor(this);
setFont(g);
DisplaysText=true;
final double dx=Math.cos(A1+A/2), dy=Math.sin(A1+A/2);
// if (s.equals("90"+getUnit()) || Name.startsWith("."))
// {
//
// if (KeepClose)
// { double d=Math.sqrt(XcOffset*XcOffset+YcOffset*YcOffset);
// TX1=zc.col(X+d*dx)-3;
// TY1=zc.row(Y+d*dy)-3;
// TX2=TX1+9;
// TY2=TY1+9;
// g.drawRect(zc.col(X+d*dx)-1,
// zc.row(Y+d*dy)-1,3,3);
// }
// else
// { TX1=zc.col(X+zc.dx(R*LabelScale)*dx+XcOffset)-3;
// TY1=zc.row(Y+zc.dy(R*LabelScale)*dy+YcOffset)-3;
// TX2=TX1+9;
// TY2=TY1+9;
// g.drawRect(zc.col(X+zc.dx(R*LabelScale)*dx+XcOffset)-1,
// zc.row(Y+zc.dy(R*LabelScale)*dy+YcOffset)-1,3,3);
// }
// }
// else
// {
if (KeepClose) {
final double d=Math.sqrt(XcOffset*XcOffset+YcOffset*YcOffset);
drawCenteredLabel(g, s, zc, X+d*dx, Y+d*dy, 0, 0);
} else {
drawCenteredLabel(g, s, zc, X+zc.dx(R*LabelScale)*dx, Y+zc.dy(R*LabelScale)*dy, XcOffset, YcOffset);
}
// }
}
}
else { // angle 2D
if (!Valid||mustHide(zc)) {
return;
}
final double R=zc.col(getDisplaySize(zc))-zc.col(0);
final double c1=zc.col(X)-R, r1=zc.row(Y)-R;
// paint:
double DA=(A2-A1)/Math.PI*180;
if (DA<0) {
DA+=360;
} else if (DA>=360) {
DA-=360;
}
if (visible(zc)) {
if (isStrongSelected()&&g instanceof MainGraphics) {
((MainGraphics) g).drawMarkerArc(c1+R, r1+R, R, A1/Math.PI*180, DA);
}
if (Filled) {
if (DisplaySize==RECT) {
final double dx1=Math.cos(A1), dy1=Math.sin(A1), dx2=Math.cos(A1+DA/180*Math.PI), dy2=Math.sin(A1+DA/180*Math.PI);
double dx3=dx1+dx2, dy3=dy1+dy2;
if (DA>180) {
dx3=-dx3;
dy3=-dy3;
}
if (Selected||getColorType()!=THIN) {
g.setColor(this);
g.drawLine(c1+R+R*dx1, r1+R-R*dy1, c1+R+R*dx3, r1+R-R*dy3);
g.drawLine(c1+R+R*dx3, r1+R-R*dy3, c1+R+R*dx2, r1+R-R*dy2);
}
x[0]=c1+R;
y[0]=r1+R;
x[1]=c1+R+R*dx1;
y[1]=r1+R-R*dy1;
x[2]=c1+R+R*dx3;
y[2]=r1+R-R*dy3;
x[3]=c1+R+R*dx2;
y[3]=r1+R-R*dy2;
g.fillPolygon(x, y, 4, false,
getColorType()!=THICK, this);
} else {
if (Math.abs(DA-90)<0.0000001) {
final double dx1=Math.cos(A1), dy1=Math.sin(A1), dx2=Math.cos(A1+DA/180*Math.PI), dy2=Math.sin(A1+DA/180*Math.PI);
final double dx3=dx1+dx2, dy3=dy1+dy2;
x[0]=c1;
y[0]=r1;
x[0]=c1+R;
y[0]=r1+R;
x[1]=c1+R+R*dx1;
y[1]=r1+R-R*dy1;
x[2]=c1+R+R*dx3;
y[2]=r1+R-R*dy3;
x[3]=c1+R+R*dx2;
y[3]=r1+R-R*dy2;
g.fillPolygon(x, y, 4, false, getColorType()!=THICK,
this);
g.setColor(this);
g.drawLine(x[1], y[1], x[2], y[2]);
g.drawLine(x[2], y[2], x[3], y[3]);
} else {
g.fillArc(c1, r1, 2*R, 2*R, A1/Math.PI*180, DA,
Selected||getColorType()!=THIN,
getColorType()!=THICK, true, this);
}
}
} else {
g.setColor(this);
if (DisplaySize==RECT) {
final double dx1=Math.cos(A1), dy1=Math.sin(A1), dx2=Math.cos(A1+DA/180*Math.PI), dy2=Math.sin(A1+DA/180*Math.PI);
g.drawLine(c1+R+R*dx1, r1+R-R*dy1, c1+R+R*(dx1+dx2), r1+R-R*(dy1+dy2));
g.drawLine(c1+R+R*(dx1+dx2), r1+R-R*(dy1+dy2), c1+R+R*dx2, r1+R-R*dy2);
} else {
if (Math.abs(DA-90)<0.0000001) {
final double dx1=Math.cos(A1), dy1=Math.sin(A1), dx2=Math.cos(A1+DA/180*Math.PI), dy2=Math.sin(A1+DA/180*Math.PI);
final double dx3=dx1+dx2, dy3=dy1+dy2;
x[1]=c1+R+R*dx1;
y[1]=r1+R-R*dy1;
x[2]=c1+R+R*dx3;
y[2]=r1+R-R*dy3;
x[3]=c1+R+R*dx2;
y[3]=r1+R-R*dy2;
g.setColor(this);
g.drawLine(x[1], y[1], x[2], y[2]);
g.drawLine(x[2], y[2], x[3], y[3]);
} else {
g.drawCircleArc(c1+R, r1+R, R, A1/Math.PI*180,
DA, this);
}
}
}
}
final String s=translateToUnicode(getDisplayText());
if (!s.equals("")) {
g.setLabelColor(this);
setFont(g);
DisplaysText=true;
final double dx=Math.cos(A1+A/2), dy=Math.sin(A1+A/2);
// if (s.equals("90"+getUnit()) || Name.startsWith("."))
// {
//
// if (KeepClose)
// { double d=Math.sqrt(XcOffset*XcOffset+YcOffset*YcOffset);
// TX1=zc.col(X+d*dx)-3;
// TY1=zc.row(Y+d*dy)-3;
// TX2=TX1+9;
// TY2=TY1+9;
// g.drawRect(zc.col(X+d*dx)-1,
// zc.row(Y+d*dy)-1,3,3);
// }
// else
// { TX1=zc.col(X+zc.dx(R*LabelScale)*dx+XcOffset)-3;
// TY1=zc.row(Y+zc.dy(R*LabelScale)*dy+YcOffset)-3;
// TX2=TX1+9;
// TY2=TY1+9;
// g.drawRect(zc.col(X+zc.dx(R*LabelScale)*dx+XcOffset)-1,
// zc.row(Y+zc.dy(R*LabelScale)*dy+YcOffset)-1,3,3);
// }
// }
// else
// {
if (KeepClose) {
final double d=Math.sqrt(XcOffset*XcOffset+YcOffset*YcOffset);
drawCenteredLabel(g, s, zc, X+d*dx, Y+d*dy, 0, 0);
} else {
drawCenteredLabel(g, s, zc, X+zc.dx(R*LabelScale)*dx, Y+zc.dy(R*LabelScale)*dy, XcOffset, YcOffset);
}
// }
}
}
}
@Override
public boolean canKeepClose() {
return true;
}
@Override
public void setKeepClose(final double x, final double y) {
KeepClose=true;
XcOffset=x-X;
YcOffset=y-Y;
}
double getDisplaySize(final ZirkelCanvas zc) {
double R=zc.dx(12*zc.pointSize());
if (DisplaySize==SMALL||DisplaySize==RECT) {
R/=2;
} else if (DisplaySize==LARGER) {
R*=2;
} else if (DisplaySize==LARGE) {
final double dx=P1.getX()-X, dy=P1.getY()-Y;
R=Math.sqrt(dx*dx+dy*dy);
}
return R;
}
public double getLength() {
return A;
}
@Override
public boolean fixed() {
return Fixed;
}
@Override
public void setFixed(final boolean flag) {
Fixed=flag;
updateText();
}
@Override
public void setFixed(final String s) {
Fixed=true;
E=new Expression(s, getConstruction(), this);
updateText();
}
@Override
public boolean canFix() {
return P3.moveableBy(this);
}
@Override
public void printArgs(final XmlWriter xml) {
if (P1!=null) {
xml.printArg("first", P1.getName());
xml.printArg("root", P2.getName());
xml.printArg("second", P3.getName());
}
if (DisplaySize==SMALL) {
xml.printArg("display", "small");
}
if (DisplaySize==NORMALSIZE) {
xml.printArg("display", "normalsize");
}
if (DisplaySize==LARGE) {
xml.printArg("display", "large");
}
if (DisplaySize==LARGER) {
xml.printArg("display", "larger");
}
if (DisplaySize==RECT) {
xml.printArg("display", "rectangle");
}
if (Filled) {
xml.printArg("filled", "true");
}
if (Fixed&&E!=null) {
xml.printArg("fixed", E.toString());
}
if (!Obtuse) {
xml.printArg("acute", "true");
}
super.printArgs(xml);
}
@Override
public void setDisplaySize(final int i) {
DisplaySize=i;
}
@Override
public int getDisplaySize() {
return DisplaySize;
}
@Override
public Enumeration depending() {
super.depending();
if (P1==null) {
return DL.elements();
}
if (!Fixed) {
return depset(P1, P2, P3);
} else {
depset(P1, P2, P3);
final Enumeration e=E.getDepList().elements();
while (e.hasMoreElements()) {
DL.add((ConstructionObject) e.nextElement());
}
return DL.elements();
}
}
@Override
public boolean equals(final ConstructionObject o) {
if (!(o instanceof AngleObject)||!o.valid()) {
return false;
}
final AngleObject l=(AngleObject) o;
return equals(X, l.X)&&equals(Y, l.Y)&&equals(A1, l.A1)&&equals(A2, l.A2);
}
public static char Translation[]={'a', '\u03B1', 'A', '\u0391', 'b',
'\u03B2', 'B', '\u0392', 'c', '\u03B3', 'C', '\u0393', 'd',
'\u03B4', 'D', '\u0394', 'e', '\u03B5', 'E', '\u0395', 'f',
'\u03D5', 'F', '\u03A6', 'g', '\u03B3', 'G', '\u0393', 'h',
'\u03B7', 'H', '\u0397', 'i', '\u03B9', 'I', '\u0399', 'k',
'\u03BA', 'K', '\u039A', 'l', '\u03BB', 'L', '\u039B', 'm',
'\u03BC', 'M', '\u039C', 'n', '\u03BD', 'N', '\u039D', 'o',
'\u03BF', 'O', '\u03A9', 'p', '\u03C0', 'P', '\u03A0', 'q',
'\u03C7', 'Q', '\u03A7', 'r', '\u03C1', 'R', '\u03A1', 's',
'\u03C3', 'S', '\u03A3', 't', '\u03C4', 'T', '\u03A4', 'u',
'\u03C5', 'U', '\u03A5', 'v', '\u03C8', 'V', '\u03A8', 'w',
'\u03C9', 'W', '\u03A9', 'x', '\u03BE', 'X', '\u039E', 'y',
'\u03C7', 'Y', '\u03A7', 'z', '\u03B6', 'Z', '\u0396',};
public static String translateToUnicode(final String s) {
if (s.startsWith("$")) {
return s;
}
if (s.indexOf('\\')<0) {
return s;
}
final StringBuffer b=new StringBuffer();
for (int i=0; i<s.length(); i++) {
char c=s.charAt(i);
if (c!='\\') {
b.append(c);
} else {
i++;
if (i<s.length()) {
c=s.charAt(i);
if (c=='0') {
int n=0;
i++;
while (i<s.length()) {
final char ch=s.charAt(i);
if (ch>='0'&&ch<='9') {
n=n*16+(int) (ch-'0');
} else if (ch>='A'&&ch<='F') {
n=n*16+(int) (ch-'A'+10);
} else {
break;
}
i++;
}
if (n>0) {
c=(char) n;
b.append(c);
}
i--;
continue;
}
int j=0;
for (j=0; j<Translation.length; j+=2) {
if (Translation[j]==c) {
b.append(Translation[j+1]);
break;
}
}
if (j>=Translation.length) {
b.append(c);
}
}
}
}
return b.toString();
}
@Override
public void translate() {
P1=(PointObject) P1.getTranslation();
P2=(PointObject) P2.getTranslation();
P3=(PointObject) P3.getTranslation();
if (Fixed) {
try {
setFixed(E.toString());
E.translate();
} catch (final Exception e) {
Fixed=false;
}
}
}
@Override
public String getE() {
if (Fixed&&E!=null) {
return E.toString();
} else {
if (P1.is3D()&&P2.is3D()&&P3.is3D()) return ""+round(A3D/Math.PI*180);
else return ""+round(A/Math.PI*180);
}
}
@Override
public double getValue() throws ConstructionException {
if (!Valid) {
throw new InvalidException("exception.invalid");
} else {
if (P1.is3D()&&P2.is3D()&&P3.is3D()) return A3D/Math.PI*180;
else return A/Math.PI*180;
}
}
@Override
public void setFilled(final boolean flag) {
Filled=flag;
}
@Override
public boolean isFilled() {
return Filled;
}
@Override
public boolean maybeTransparent() {
return true;
}
@Override
public boolean isFilledForSelect() {
return false;
}
public double containsInside(final PointObject P) {
final double dx=P.getX()-X, dy=P.getY()-Y;
double a=Math.atan2(dy, dx);
if (a<0) {
a+=2*Math.PI;
}
if (a<A1) {
a+=2*Math.PI;
}
final double c=1e-5;
if (a>A1&&a<A1+A) {
return 1;
} else if (a>A1-c&&a<A1+A+c) {
return 0.5;
}
return 0;
}
public boolean keepInside(final PointObject P) {
if (containsInside(P)>0) {
return true;
}
final double x=P.getX(), y=P.getY();
final double x1=P2.getX(), y1=P2.getY();
double xmin=x1, ymin=y1, dmin=1e20;
double x2=P1.getX(), y2=P1.getY();
double dx=x2-x1, dy=y2-y1;
double r=dx*dx+dy*dy;
double h=dx*(x-x1)/r+dy*(y-y1)/r;
if (h<0) {
h=0;
}
double xh=x1+h*dx, yh=y1+h*dy;
double dist=Math.sqrt((x-xh)*(x-xh)+(y-yh)*(y-yh));
if (dist<dmin) {
dmin=dist;
xmin=xh;
ymin=yh;
}
x2=P3.getX();
y2=P3.getY();
dx=x2-x1;
dy=y2-y1;
r=dx*dx+dy*dy;
h=dx*(x-x1)/r+dy*(y-y1)/r;
if (h<0) {
h=0;
}
xh=x1+h*dx;
yh=y1+h*dy;
dist=Math.sqrt((x-xh)*(x-xh)+(y-yh)*(y-yh));
if (dist<dmin) {
dmin=dist;
xmin=xh;
ymin=yh;
}
P.move(xmin, ymin);
return false;
}
public PointObject getP1() {
return P1;
}
public PointObject getP2() {
return P2;
}
public PointObject getP3() {
return P3;
}
}