/* 

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;
    }
}