/*

Copyright 2006 Rene Grothmann, modified by Eric Hakenholz

This file is part of C.a.R. software.

C.a.R. is a free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

C.a.R. is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */
// with addons by Dibs for 3D
package rene.zirkel.objects;

// file: PointObject.java
import eric.GUI.pipe_tools;
import eric.GUI.palette.PaletteManager;
import eric.JPointName;
import eric.JZirkelCanvas;

import java.awt.Color;
import java.awt.Rectangle;
import java.util.Enumeration;
import java.util.Vector;
import rene.gui.Global;
import rene.util.xml.XmlWriter;
import rene.zirkel.ZirkelCanvas;
import rene.zirkel.construction.Construction;
import rene.zirkel.expression.Expression;
import rene.zirkel.expression.ExpressionColor;
import rene.zirkel.graphics.MainGraphics;
import rene.zirkel.graphics.MyGraphics;
import rene.zirkel.structures.MagnetObj;

public class PointObject extends ConstructionObject implements MoveableObject,
        DriverObject {

    protected double X, Y;
    protected double X3D, Y3D, Z3D;
    protected boolean Is3D; //Dibs : the point is 3D
    protected boolean BarycentricCoordsInitialzed=false;
    protected double Gx=0, Gy=0; // Barycentric coords, if it's inside a
    // polygon.
    protected double Alpha; // parameter relative zu object
    protected boolean AlphaValid=false; // Alpha is valid
    protected boolean UseAlpha=false; // Use Alpha at all
    protected boolean Moveable, Fixed;
    protected boolean Fixed3D;         //Dibs
    // private static Count N=new Count();
    private static JPointName PointLabel=new JPointName();
    protected int Type=0;
    public double RDP2=16;
    public final static int SQUARE=0, DIAMOND=1, CIRCLE=2, DOT=3,
            CROSS=4, DCROSS=5;
    public static int MaxType=3;
    protected Expression EX, EY;
    protected Expression EX3D, EY3D, EZ3D;
    // private ConstructionObject Bound=null; // point is on a line etc.
    private boolean Later; // bound is later in construction
    private String LaterBind="";
    private boolean KeepInside; // keep point inside bound
    private boolean DontUpdate=false;
    private double Increment=0; // increment to keep on grid
    private ConstructionObject Bound=null; // point is on a line etc.
    private double BoundOrder=Double.NaN; // Only for points on parametric
    // curves made with "points only"
    protected ConstructionObject MovedBy;
    private double LASTX=Double.NaN, LASTY=Double.NaN;
    private final Vector magnetObjects=new Vector();
    Expression magnetRayExp=null;
    private int CurrentMagnetRay=Integer.MIN_VALUE;
    private ConstructionObject CurrentMagnetObject=null;
    public ConstructionObject VirtualBound=null;

    // The object that may have moved this point
    public PointObject(final Construction c, final double x, final double y) {
        super(c);
        X=x;
        Y=y;
        Is3D=false;
        X3D=0;
        Y3D=0;
        Z3D=0;
        Moveable=true;
        Fixed=false;
        Fixed3D=false;
        setColor(ColorIndex, SpecialColor);
        setShowName(false);
        updateText();
        Type=0;
        setMagnetRayExp("20");
    }

    public PointObject(final Construction c, final double x, final double y,
            final ConstructionObject bound) {

        this(c, x, y);
        Bound=bound;
        initAlpha();
	updateText();
    }

    public PointObject(final Construction c, final String name) {
        super(c, name);
        X=0;
        Y=0;
        Is3D=false;
        X3D=0;
        Y3D=0;
        Z3D=0;
        Moveable=true;
        Fixed=false;
        Fixed3D=false;
        setColor(ColorIndex, SpecialColor);
        updateText();
        Type=0;
        setMagnetRayExp("20");
    }


    public void initAlpha() {
        if ((Bound!=null)&&(Bound instanceof PrimitiveCircleObject)) {
            PrimitiveCircleObject circ=(PrimitiveCircleObject) Bound;
            if (circ.hasRange()&&(circ.StartPt!=this)&&(circ.EndPt!=this)&&(isPointOn())) {
                circ.detectArc3Pts();
                double soe=circ.computeSOE();
                double sop=circ.computeSOP(this);
                if (soe!=0) {
                    setAlpha(sop/soe);
//                    if (circ.isArc3pts&&!circ.StartPt.equals(circ.RealCorrespondingStartPt)) {
//                        setAlpha(1-sop/soe);
//                    }
                }
            }
        }
    }

    public static void setPointLabel(final JPointName jpl) {
        PointLabel=jpl;
    }

    @Override
    public void setName() {
        if ((!SuperHidden)&&(!Hidden)) {
            Name=PointLabel.getBetterName(Cn, false);
        } else {
            Name=JPointName.getGenericName(Cn);
        }
    }

    @Override
    public void setNameWithNumber(String n) {
        Name="";
        if (Cn!=null) {
            ConstructionObject o=Cn.find(n);
            if (o!=null) {
                while (o!=null&&o!=this) {
                    Name=JPointName.getGenericName(Cn);
                    n=Name;
                    Name="";
                    o=Cn.find(n);
                }
                Name=n;
            } else {
                Name=n;
            }
        } else {
            Name=n;
        }
    }

    @Override
    public String getTag() {
        if (Bound==null) {
            return "Point";
        } else {
            return "PointOn";
        }
    }

    @Override
    public int getN() {
        return N.next();
    }

    // public void setDefaults ()
    // { super.setDefaults();
    // Type=Cn.DefaultType;
    // }
    @Override
    public void setDefaults() {
        setShowName(Global.getParameter("options.point.shownames", false));
        setShowValue(Global.getParameter("options.point.showvalues", false));
        setColor(Global.getParameter("options.point.color", 0), Global.getParameter("options.point.pcolor", (ExpressionColor) null, this));
        setColorType(Global.getParameter("options.point.colortype", 0));
        setHidden(Cn.Hidden);
        setObtuse(Cn.Obtuse);
        setSolid(Cn.Solid);
        setLarge(Global.getParameter("options.point.large", false));
        setBold(Global.getParameter("options.point.bold", false));
        Type=Cn.DefaultType;



    }

    @Override
    public void setTargetDefaults() {
        setShowName(Global.getParameter("options.point.shownames", false));
        setShowValue(Global.getParameter("options.point.showvalues", false));
        setColor(Global.getParameter("options.point.color", 0), Global.getParameter("options.point.pcolor", (ExpressionColor) null, this));
        setColorType(Global.getParameter("options.point.colortype", 0));
        setLarge(Global.getParameter("options.point.large", false));
        setBold(Global.getParameter("options.point.bold", false));
        Type=Cn.DefaultType;
    }
    private double Delta;

    @Override
    public double changedBy() {
        return Delta;
    }

    @Override
    synchronized public void validate() {
        if (DontUpdate) {
            return;
        }

        updateMagnetObjects();
        followMagnetObject();

        // magnet();
        // System.out.println(getName()+" : validate !");

        MovedBy=null;
        Delta=0.0;
        Valid=true;
        if (Fixed3D&&EX3D!=null&&EX3D.isValid()) {
            try {
                X3D=EX3D.getValue();
            } catch (final Exception e) {
                Valid=false;
                return;
            }
        }
        if (Fixed3D&&EY3D!=null&&EY3D.isValid()) {
            try {
                Y3D=EY3D.getValue();
            } catch (final Exception e) {
                Valid=false;
                return;
            }
        }
        if (Fixed3D&&EZ3D!=null&&EZ3D.isValid()) {
            try {
                Z3D=EZ3D.getValue();
            } catch (final Exception e) {
                Valid=false;
                return;
            }
        }
        if (Fixed&&EX!=null&&EX.isValid()) {
            try {
                X=EX.getValue();
            } catch (final Exception e) {
                Valid=false;
                return;
            }
        }
        if (Fixed&&EY!=null&&EY.isValid()) {
            try {
                Y=EY.getValue();
            } catch (final Exception e) {
                Valid=false;
                return;
            }
        }
        if (Bound!=null&&!Bound.isInConstruction()) {
            Bound=null;
        }
        if (Bound!=null&&!Bound.valid()) {
            Valid=false;
            return;
        }
        if (Increment>1e-4) {
            X=Math.floor(X/Increment+0.5)*Increment;
            Y=Math.floor(Y/Increment+0.5)*Increment;
        }
        if (Bound!=null) {
            final double x=X, y=Y;
            if (KeepInside&&Bound instanceof InsideObject) {
                ((InsideObject) Bound).keepInside(this);
            } else if (!KeepInside&&Bound instanceof PointonObject) {
                if (!AlphaValid||!UseAlpha) {
                    project(Bound);
                } else {
                    project(Bound, Alpha);
                }
            }
            if (Later) {
                Delta=Math.sqrt((x-X)*(x-X)+(y-Y)*(y-Y));
            }
        }
        if (getConstruction().is3D()&&getBound()!=null) { // Dibs : 2D -> 3D
        	if (getBound() instanceof AreaObject) {
        			AreaObject surface= (AreaObject) getBound();
        			if (((AreaObject)surface).V.size()>2&&((PointObject) surface.V.get(0)).is3D()&&((PointObject) surface.V.get(1)).is3D()&&((PointObject) surface.V.get(2)).is3D()) {
        				try {
        					double x0=((PointObject) surface.V.get(0)).getX3D();
            				double y0=((PointObject) surface.V.get(0)).getY3D();
            				double z0=((PointObject) surface.V.get(0)).getZ3D();
            				double x1=((PointObject) surface.V.get(1)).getX3D();
            				double y1=((PointObject) surface.V.get(1)).getY3D();
            				double z1=((PointObject) surface.V.get(1)).getZ3D();
            				double x2=((PointObject) surface.V.get(2)).getX3D();
            				double y2=((PointObject) surface.V.get(2)).getY3D();
            				double z2=((PointObject) surface.V.get(2)).getZ3D();
            				double x_O=getConstruction().find("O").getX();
            				double x_X=getConstruction().find("X").getX();
            				double x_Y=getConstruction().find("Y").getX();
            				double x_Z=getConstruction().find("Z").getX();
            				double y_O=getConstruction().find("O").getY();
            				double y_X=getConstruction().find("X").getY();
            				double y_Y=getConstruction().find("Y").getY();
            				double y_Z=getConstruction().find("Z").getY();
            				double coeffa=(x1-x0)*(x_X-x_O)+(y1-y0)*(x_Y-x_O)+(z1-z0)*(x_Z-x_O);
            				double coeffb=(x2-x0)*(x_X-x_O)+(y2-y0)*(x_Y-x_O)+(z2-z0)*(x_Z-x_O);
            				double coeffc=(x1-x0)*(y_X-y_O)+(y1-y0)*(y_Y-y_O)+(z1-z0)*(y_Z-y_O);
            				double coeffd=(x2-x0)*(y_X-y_O)+(y2-y0)*(y_Y-y_O)+(z2-z0)*(y_Z-y_O);
            				double coeffe=getX()-x_O-x0*(x_X-x_O)-y0*(x_Y-x_O)-z0*(x_Z-x_O);
            				double coefff=getY()-y_O-x0*(y_X-y_O)-y0*(y_Y-y_O)-z0*(y_Z-y_O);
            				double alpha1=(coeffe*coeffd-coefff*coeffb)/(coeffa*coeffd-coeffb*coeffc);
            				double beta1=(coeffa*coefff-coeffc*coeffe)/(coeffa*coeffd-coeffb*coeffc);
            				setX3D(x0+alpha1*(x1-x0)+beta1*(x2-x0));
            				setY3D(y0+alpha1*(y1-y0)+beta1*(y2-y0));
            				setZ3D(z0+alpha1*(z1-z0)+beta1*(z2-z0));
            				setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
            				AlphaValid=false;
            				setIs3D(true);
        	            	} catch (final Exception eBary) {
        	            }
        			}
        		}
        	
        else if (getBound() instanceof TwoPointLineObject) {
    		TwoPointLineObject ligne= (TwoPointLineObject) getBound();
			if (((PointObject) ligne.getP1()).is3D()&&((PointObject) ligne.getP2()).is3D()) {
				try {
					double x1=((PointObject) ligne.getP1()).getX3D();
					double y1=((PointObject) ligne.getP1()).getY3D();
    				double z1=((PointObject) ligne.getP1()).getZ3D();
    				double x2=((PointObject) ligne.getP2()).getX3D();
    				double y2=((PointObject) ligne.getP2()).getY3D();
    				double z2=((PointObject) ligne.getP2 ()).getZ3D();
    				double x_O=getConstruction().find("O").getX();
    				double x_X=getConstruction().find("X").getX();
    				double x_Y=getConstruction().find("Y").getX();
    				double x_Z=getConstruction().find("Z").getX();
    				double alpha1=(getX()-x_O-x1*(x_X-x_O)-y1*(x_Y-x_O)-z1*(x_Z-x_O))/((x2-x1)*(x_X-x_O)+(y2-y1)*(x_Y-x_O)+(z2-z1)*(x_Z-x_O));
    				if (x1==x2&&y1==y2) {
    					double y_O=getConstruction().find("O").getY();
        				double y_X=getConstruction().find("X").getY();
        				double y_Y=getConstruction().find("Y").getY();
        				double y_Z=getConstruction().find("Z").getY();
    					alpha1=(getY()-y_O-x1*(y_X-y_O)-y1*(y_Y-y_O)-z1*(y_Z-y_O))/((x2-x1)*(y_X-y_O)+(y2-y1)*(y_Y-y_O)+(z2-z1)*(y_Z-y_O));
    				}
    				setX3D(x1+alpha1*(x2-x1));
    				setY3D(y1+alpha1*(y2-y1));
    				setZ3D(z1+alpha1*(z2-z1));
    				setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
    				//setMoveable(true);
                                //AlphaValid=false;
    				setIs3D(true);
	            	} catch (final Exception eBary) {
	            		}

					}
			}
        else if (getBound() instanceof QuadricObject) {
    		QuadricObject quadrique= (QuadricObject) getBound();
    		if (quadrique.getP()[0].is3D()&&quadrique.getP()[1].is3D()&&quadrique.getP()[2].is3D()&&quadrique.getP()[3].is3D()&&quadrique.getP()[4].is3D()) {
    			try {
					double x0=quadrique.getP()[0].getX3D();
    				double y0=quadrique.getP()[0].getY3D();
    				double z0=quadrique.getP()[0].getZ3D();
    				double x1=quadrique.getP()[1].getX3D();
    				double y1=quadrique.getP()[1].getY3D();
    				double z1=quadrique.getP()[1].getZ3D();
    				double x2=quadrique.getP()[2].getX3D();
    				double y2=quadrique.getP()[2].getY3D();
    				double z2=quadrique.getP()[2].getZ3D();
    				double x_O=getConstruction().find("O").getX();
    				double x_X=getConstruction().find("X").getX();
    				double x_Y=getConstruction().find("Y").getX();
    				double x_Z=getConstruction().find("Z").getX();
    				double y_O=getConstruction().find("O").getY();
    				double y_X=getConstruction().find("X").getY();
    				double y_Y=getConstruction().find("Y").getY();
    				double y_Z=getConstruction().find("Z").getY();
    				double coeffa=(x1-x0)*(x_X-x_O)+(y1-y0)*(x_Y-x_O)+(z1-z0)*(x_Z-x_O);
    				double coeffb=(x2-x0)*(x_X-x_O)+(y2-y0)*(x_Y-x_O)+(z2-z0)*(x_Z-x_O);
    				double coeffc=(x1-x0)*(y_X-y_O)+(y1-y0)*(y_Y-y_O)+(z1-z0)*(y_Z-y_O);
    				double coeffd=(x2-x0)*(y_X-y_O)+(y2-y0)*(y_Y-y_O)+(z2-z0)*(y_Z-y_O);
    				double coeffe=getX()-x_O-x0*(x_X-x_O)-y0*(x_Y-x_O)-z0*(x_Z-x_O);
    				double coefff=getY()-y_O-x0*(y_X-y_O)-y0*(y_Y-y_O)-z0*(y_Z-y_O);
    				double alpha1=(coeffe*coeffd-coefff*coeffb)/(coeffa*coeffd-coeffb*coeffc);
    				double beta1=(coeffa*coefff-coeffc*coeffe)/(coeffa*coeffd-coeffb*coeffc);
    				setX3D(x0+alpha1*(x1-x0)+beta1*(x2-x0));
    				setY3D(y0+alpha1*(y1-y0)+beta1*(y2-y0));
    				setZ3D(z0+alpha1*(z1-z0)+beta1*(z2-z0));
    				setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
    				//AlphaValid=false;
    				setIs3D(true);
	            	} catch (final Exception eBary) {
	            }
    			
    		}
    	}
        }
        
    }


    @Override
    public Boolean is2DObject(){
        return !Is3D;
    }

    @Override
    public void updateText() {
        if (Bound!=null) {
            setText(text1(Global.name("text.boundedpoint"), Bound.getName()));
            //setText(Global.Loc("objects.boundedpoint"));
        } else if (EX!=null&&EY!=null) {
//            setText(text2(Global.name("text.point"), "\""+EX+"\"", "\""+EY+"\""));
            setText(Global.Loc("objects.point"));
        } else {
//            setText(text2(Global.name("text.point"), ""+round(X), ""+round(Y)));
            setText(Global.Loc("objects.point"));
        }
    }
    static double x[]=new double[4], y[]=new double[4];

    @Override
    public void paint(final MyGraphics g, final ZirkelCanvas zc) {
        DisplaysText=false;
        if (!Valid||mustHide(zc)) {
            return;
        }
        final double size=drawPoint(g, zc, this, X, Y, Type);
        if (tracked()) {
            zc.UniversalTrack.drawTrackPoint(this, X, Y, Type);
        }
        final String s=AngleObject.translateToUnicode(getDisplayText());
        if (!s.equals("")) {
            g.setLabelColor(this);
            DisplaysText=true;
            setFont(g);
            final double d=Math.sqrt(XcOffset*XcOffset+YcOffset*YcOffset);
            if (!KeepClose||d<1e-10) {
                TX1=zc.col(X+XcOffset)+2*size;
                TY1=zc.row(Y+YcOffset)+2*size;
                drawLabel(g, s);
            } else {
                drawPointLabel(g, s, zc, X, Y, YcOffset/d, -XcOffset/d, 0,
                        0);
            }
        }
    }

    static public double drawPoint(final MyGraphics g, final ZirkelCanvas zc,
            final ConstructionObject o, final double X, final double Y,
            final int type) {
        double size=zc.pointSize();

        final double r=zc.col(X), c=zc.row(Y);
        final double un=zc.getOne();
//        if (size<1) {
//            size=1;
//        }
        // System.out.println(size);
        if (o.visible(zc)) {
            if (o.isStrongSelected()&&g instanceof MainGraphics) {
                ((MainGraphics) g).drawMarkerLine(r, c, r, c);
            }
            g.setColor(o);
            switch (type) {
                case SQUARE:
                    final double sx=r-size-un,
                     sy=c-size-un,
                     sw=2*(size+un);
                    if (o.getColorType()==THICK) {
                        g.fillRect(sx, sy, sw, sw, true, false, o);
                    } else {
                        g.fillRect(sx, sy, sw, sw, new Color(255, 255, 255));
                    }
                    g.setColor(o);
                    g.drawRect(sx, sy, sw, sw);
                    break;
                case DIAMOND:
                    final double dx=r-size-un,
                     dy=c-size-un,
                     dw=2*(size+un);
                    g.drawDiamond(dx, dy, dw, (o.getColorType()==THICK), o);
                    break;
                case CIRCLE:
                    double cx=r-size-un,
                     cy=c-size-un,
                     cw=2*size+2*un;
                    if (o.getColorType()==THICK) {
                        g.fillOval(cx, cy, cw, cw, true, false, o);
                    } else {
                        g.fillOval(cx, cy, cw, cw, new Color(255, 255, 255));
                        g.setColor(o);
                        g.drawOval(cx, cy, cw, cw);
                    }
                    break;
                case DOT:
                    if (o.getColorType()==THICK) {
                        g.fillRect(r, c, un, un, true, false, o);
                    } else {
                        g.drawLine(r, c, r, c);
                    }
                    break;
                case CROSS:
                    if (o.getColorType()==THICK) {
                        g.drawThickLine(r-size-un, c, r+size+un, c);
                        g.drawThickLine(r, c-size-un, r, c+size+un);
                    } else {
                        g.drawLine(r-size-un, c, r+size+un, c);
                        g.drawLine(r, c-size-un, r, c+size+un);
                    }
                    break;
                case DCROSS:
                    final double crx=r-size-un,
                     cry=c-size-un,
                     crw=2*(size+un);
                    if (o.getColorType()==THICK) {
                        g.drawThickLine(crx, cry, crx+crw, cry+crw);
                        g.drawThickLine(crx+crw, cry, crx, cry+crw);
                    } else {
                        g.drawLine(crx, cry, crx+crw, cry+crw);
                        g.drawLine(crx+crw, cry, crx, cry+crw);
                    }
                    break;
            }
        }
        return size;
    }

    @Override
    public String getDisplayValue() {
    	if (is3D()||PaletteManager.isSelected("boundedpoint")) return "("+Global.getLocaleNumber(X3D, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
                :";")+Global.getLocaleNumber(Y3D, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
                        :";")+Global.getLocaleNumber(Z3D, "lengths")+")";
    	else return "("+Global.getLocaleNumber(X, "lengths")+(Global.getParameter("options.germanpoints", false)?"|"
                :";")+Global.getLocaleNumber(Y, "lengths")+")";
    }

    @Override
    public String getCDPDisplayValue() {
        return "("+Global.getCDPLocaleNumber(X, 2)+" "+(Global.getParameter("options.germanpoints", false)?"|"
                :";")+Global.getCDPLocaleNumber(Y, 2)+")";
    }

    @Override
    public boolean isInRect(Rectangle r, ZirkelCanvas zc){
        return r.contains(zc.col(X),zc.row(Y));
    }

    @Override
    public boolean nearto(final int x, final int y, final ZirkelCanvas zc) {
        if (!displays(zc)) {
            return false;
        }
        final double c=zc.col(X), r=zc.row(Y);
        final int size=(int) zc.selectionSize();
        Value=Math.abs(x-c)+Math.abs(y-r);
        return Value<=size*3/2;
    }

    public boolean nearto(final PointObject p) {
    	try {
            X=EX.getValue();
        } catch (final Exception e) {
            Valid=false;
            return false;
        }
    	try {
            Y=EY.getValue();
        } catch (final Exception e) {
            Valid=false;
            return false;
        }
        if (!Valid) {
            return false;
        }
        final double dx=p.X-X, dy=p.Y-Y;
        return Math.sqrt(dx*dx+dy*dy)<1e-9;
    }

    public double distanceTo(final int x, final int y, final ZirkelCanvas zc) {
        final double dx=x-zc.col(X), dy=y-zc.row(Y);
        return Math.sqrt(dx*dx+dy*dy);
    }

    @Override
    public double getX() {
        return X;
    }

    @Override
    public double getY() {
        return Y;
    }
    
    @Override
    public double getX3D() {
    	return X3D;
    }
    
    @Override
    public double getY3D() {
    	return Y3D;
    }
    
    @Override
    public double getZ3D() {
    	return Z3D;
    }
    
    public void setX3D(double x) {
    	X3D = x;
    }
    
    public void setY3D(double y) {
    	Y3D = y;
    }
    
    public void setZ3D(double z) {
    	Z3D = z;
    }
    
    public boolean is3D() {
    	return Is3D;
    }
    
    public void setIs3D(boolean u) {
    	Is3D = u;
    }

    @Override
    public boolean moveable() {
        boolean fixed=Fixed;
        boolean fixed3D=Fixed3D;
        if (dependsOnItselfOnly()) {
            fixed=false;
        }
        if (Is3D) return Moveable&&!fixed3D&&!Keep;
        else return Moveable&&!fixed&&!Keep;
    }

    /**
     * Check if the point depends on itself and no other object. Such points are
     * moveable, even if they are fixed.
     *
     * @return
     */
    public boolean dependsOnItselfOnly() {
        boolean res=false;
        Enumeration e=depending();
        while (e.hasMoreElements()) {
            if ((ConstructionObject) e.nextElement()==this) {
                res=true;
                break;
            }
        }
        e=depending();
        while (e.hasMoreElements()) {
            if ((ConstructionObject) e.nextElement()!=this) {
                res=false;
                break;
            }
        }
        return res;
    }

    public boolean dependsOnParametersOnly() {
        final Enumeration e=depending();
        while (e.hasMoreElements()) {
            if (!((ConstructionObject) e.nextElement()).isParameter()) {
                return false;
            }
        }
        return true;
    }

    /**
     * @return o can move this point (moveable and not moved by something else)
     */
    public boolean moveableBy(final ConstructionObject o) {
        if (Bound!=null) {
            return false;
        }
        return moveable()&&(MovedBy==null||MovedBy==o);
    }

    public boolean moveablePoint() {
        if (Bound!=null) {
            return true;
        }
        return Moveable&&!Keep;
    }

    public boolean setBound(final String name) {
        if (name.equals("")) {
            Bound=null;
            setFixed(false);
            setFixed3D(false);
            Later=false;
            return true;
        }
        try {
            Bound=null;
            final ConstructionObject o=Cn.find(name);
            if (o instanceof PointonObject) {
                Bound=o;
                Moveable=true;
                Fixed=false;
                Fixed3D=false;
                KeepInside=false;
            } else if (o instanceof InsideObject) {
                Bound=o;
                Moveable=true;
                Fixed=false;
                Fixed3D=false;
                KeepInside=true;
            } else {
                return false;
            }
        } catch (final Exception e) {
            return false;
        }
        if (Cn.before(this, Bound)) {
            Cn.needsOrdering();
            Cn.dovalidate();
        }
        updateText();
        clearMagnetObjects();
        return true;
    }

    public void setBound(final ConstructionObject bound) {
        Bound=bound;
    }

    public boolean haveBoundOrder() {
        return (!Double.isNaN(BoundOrder));
    }

    public void setBoundOrder(final double boundorder) {
        BoundOrder=boundorder;
    }

    public void clearBoundOrder() {
        BoundOrder=Double.NaN;
    }

    public ConstructionObject getBound() {
        return Bound;
    }

    public double getBoundOrder() {
        return BoundOrder;
    }

    public void setMoveable(final boolean flag) {
        Moveable=flag;
    }

    @Override
    public boolean fixed() {
        return Fixed;
    }

    @Override
    public void setFixed(final boolean flag) {
        Fixed=flag;
        if (!Fixed) {
            EX=EY=null;
        }
        updateText();
    }
    
    public boolean fixed3D() {
        return Fixed3D;
    }

    @Override
    public void setFixed3D(final boolean flag) {
        Fixed3D=flag;
        if (!Fixed3D) {
            EX3D=null;
            EY3D=null;
            EZ3D=null;
        }
        updateText();
    }


    @Override
    public void setFixed(final String x, final String y) {
        Fixed=true;
        EX=new Expression(x, getConstruction(), this);
        EY=new Expression(y, getConstruction(), this);
        updateText();
    }
    
    @Override
    public void setFixed(final String x3D, final String y3D, final String z3D) {
        Fixed3D=true;
        EX3D=new Expression(x3D, getConstruction(), this);
        EY3D=new Expression(y3D, getConstruction(), this);
        EZ3D=new Expression(z3D, getConstruction(), this);
    	setFixed("x(O)+("+EX3D+")*(x(X)-x(O))+("+EY3D+")*(x(Y)-x(O))+("+EZ3D+")*(x(Z)-x(O))", "y(O)+("+EX3D+")*(y(X)-y(O))+("+EY3D+")*(y(Y)-y(O))+("+EZ3D+")*(y(Z)-y(O))");	

        updateText();
    }

    public void validCoordinates() throws Exception {
        boolean val=(EX.isValid())&&(EY.isValid());
        if (!val) {
            throw new Exception("");
        }
    }
    
    public void validCoordinates3D() throws Exception {
        boolean val=(EX3D.isValid())&&(EY3D.isValid())&&(EZ3D.isValid());
        if (!val) {
            throw new Exception("");
        }
    }
    /* This part is for "monkey" animation. Point have a spin and it keeps going
     * until it reaches a window border. At this time, spin is recomputed and moves
     * following its new trajectory.
     */
    private double spin=Math.random()*2*Math.PI;

    public boolean insidewindow() {
        return insidewindow(X, Y);
    }

    public boolean insidewindow(double x, double y) {
        boolean b=(x>Cn.getX()-Cn.getW());
        b=b&&(x<Cn.getX()+Cn.getW());
        b=b&&(y<Cn.getY()+Cn.getH()/2);
        b=b&&(y>Cn.getY()-Cn.getH()/2);
        return b;
    }

    public void shake(ZirkelCanvas zc) {
        if(zc.isDP()){
            FixedCircleObject c = (FixedCircleObject) zc.getConstruction().find("Hz");
            if(c!=null){
                RDP2=c.getR();
                RDP2*=RDP2; //set to the square
            }
        }
        if (!insidewindow(X, Y)||(zc.isDP()&&(X*X+Y*Y>RDP2))) {
            return;
        }
        spin+=Math.random()-0.5;
        double d=zc.monkeySpeed()/4;
        double x=X+d*Math.cos(spin)/Cn.getPixel();
        double y=Y+d*Math.sin(spin)/Cn.getPixel();
        while (!insidewindow(x, y)||(zc.isDP()&&(x*x+y*y>RDP2))) {
            //      spin=Math.random()*2*Math.PI;
            //demi-tour carrément
            spin+=Math.PI;
            x=X+d*Math.cos(spin)/Cn.getPixel();
            y=Y+d*Math.sin(spin)/Cn.getPixel();
        }
        move(x, y);
//        magnet();
        validate();
    }

    /* this part is for exercise purpose :
     *
     */
    public void alea() {
        if (!insidewindow(X, Y)) {
            return;
        }
        double left=Cn.getX()-Cn.getW();
        double top=Cn.getY()+Cn.getH()/2;
        double x=left+Math.random()*2*Cn.getW();
        double y=top-Math.random()*Cn.getH();
        while (!insidewindow(x, y)) {
            x=left+Math.random()*2*Cn.getW();
            y=top-Math.random()*Cn.getH();
        }
        move(x, y);
//        magnet();
        validate();
    }

    @Override
    public void move(final double x, final double y) {
        if ((X==x)&&(Y==y)) {
            return;
        }
        // System.out.println(getName()+" : move !");
        X=x;
        Y=y;
        AlphaValid=false;
        computeBarycentricCoords();
    }
    
    @Override
    public void move3D(final double x3D, final double y3D, final double z3D) {
        if ((X3D==x3D)&&(Y3D==y3D)&&(Z3D==z3D)) {
            return;
        }
        // System.out.println(getName()+" : move !");
        X3D=x3D;
        Y3D=y3D;
        Z3D=z3D;
        AlphaValid=false;
        setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");
        setFixed3D(false);
        //computeBarycentricCoords();
    }

    public void setXY(final double x, final double y) {
        if ((X==x)&&(Y==y)) {
            return;
        }
        // System.out.println(getName()+" : setXY !");
        X=x;
        Y=y;
    }
    
    public void setXYZ(final double x3D, final double y3D, final double z3D) {
        if ((X3D==x3D)&&(Y3D==y3D)&&(Z3D==z3D)) {
            return;
        }
        // System.out.println(getName()+" : setXY !");
        X3D=x3D;
        Y3D=y3D;
        Z3D=z3D;
        setFixed("x(O)+("+X3D+")*(x(X)-x(O))+("+Y3D+")*(x(Y)-x(O))+("+Z3D+")*(x(Z)-x(O))", "y(O)+("+X3D+")*(y(X)-y(O))+("+Y3D+")*(y(Y)-y(O))+("+Z3D+")*(y(Z)-y(O))");

    }

    public void setXYaway(final double x, final double y, final int r) {
        if (r>0) {
            setXY(x, y);
            return;
        }

        final double d=Math.sqrt((X-x)*(X-x)+(Y-y)*(Y-y));
        final double dblr=-r/Cn.getPixel();
        double xx=x+dblr, yy=y;
        if (d!=0) {
            xx=x+(X-x)*dblr/d;
            yy=y+(Y-y)*dblr/d;
        }

        // System.out.println(Cn.getPixel());
        // System.out.println("d="+d);
        // System.out.println("xx="+xx);
        // System.out.println("yy="+yy);
        // System.out.println("****");
        setXY(xx, yy);
    }

    public void setA(final double alpha) {
        Alpha=alpha;
    }

    public void setMagnetRayExp(final String s) {
        magnetRayExp=new Expression(s, Cn, this);
    }

    public String getMagnetRayExp() {
        return magnetRayExp.toString();
    }

    public int getMagnetRay() {
        int i=20;
        try {
            i=(int) Math.round(magnetRayExp.getValue());
        } catch (final Exception ex) {
        }
        return i;
    }

    public boolean isMagnet() {
        return (CurrentMagnetObject!=null);
    }

    private boolean isMagnetObject(final String name) {
        final Enumeration e=magnetObjects.elements();
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            if (mo.name().equals(name)) {
                return true;
            }
        }
        return false;
    }

    public void removeMagnetObject(final String name) {
        final Enumeration e=magnetObjects.elements();
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            if (mo.name().equals(name)) {
                magnetObjects.remove(mo);
            }
        }
    }

    /**
     * s represents the name of an object, or the string "name:ray" where ray is
     * the specific magnetic attraction
     *
     * @param s
     */
    public void addMagnetObject(final String s) {
        final String[] mo=s.split(":");
        final String name=mo[0];
        // int ray=-1;
        String ray=""+Integer.MIN_VALUE;
        if (mo.length>1) {
            ray=mo[1];
        }

        if (name.equals(getName())) {
            return;
        }
        final ConstructionObject o=Cn.find(name);
        if ((o!=null)&&(!isMagnetObject(name))) {
            magnetObjects.add(new MagnetObj(o, ray));
        }
    }

    public void setMagnetObjects(final String namelist) {
        String st="";
        char t;
        int p=0;
        for (int i=0; i<namelist.length(); i++) {
            t=namelist.charAt(i);
            if (t=='(') {
                p++;
            } else if (t==')') {
                p--;
            }
            if ((p>0)&&(t==',')) {
                st+="@@";
            } else {
                st+=t;
            }
        }

        final String[] s=st.split(",");
        magnetObjects.removeAllElements();
        for (final String element : s) {
            st=element.replaceAll("@@", ",");
            addMagnetObject(st);
        }
    }

    public void selectMagnetObjects(final boolean b) {
        final Enumeration e=magnetObjects.elements();
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            if (mo.isInConstruction()) {
                mo.setSelected(b);
            }
        }
    }

    public void updateMagnetObjects() {
        final Enumeration e=magnetObjects.elements();
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            if (!mo.isInConstruction()) {
                magnetObjects.remove(mo);
            }
        }
    }

    public void clearMagnetObjects() {
        magnetObjects.removeAllElements();
        setMagnetRayExp("20");

    }

    public void translateMagnetObjects() {
        final Enumeration e=magnetObjects.elements();
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            mo.translate();
        }
    }

    public Vector getMagnetObjects() {
        return magnetObjects;
    }

    public String getMagnetObjectsString() {
        updateMagnetObjects();
        String s="";
        final Enumeration e=magnetObjects.elements();
        if (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            s=mo.name();
            if (mo.ray()>Integer.MIN_VALUE) {
                s+=":"+mo.rayexp();
            }
        }
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            s+=","+mo.name();
            if (mo.ray()>Integer.MIN_VALUE) {
                s+=":"+mo.rayexp();
            }
        }
        return s;
    }

    public void magnet() {
        ConstructionObject PtOnObject=null;
        ConstructionObject PtObject=null;
        final Enumeration e=magnetObjects.elements();
        int dp=Integer.MAX_VALUE, dm=Integer.MAX_VALUE;
        int rayp=0, raym=0;
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            final ConstructionObject o=mo.obj();
            final int mRay=(mo.ray()>Integer.MIN_VALUE)?mo.ray()
                    :getMagnetRay();
            final int mRayAbs=Math.abs(mRay);
            if (mRayAbs==0) {
                continue;
            }
            if (!o.valid()) {
                continue;
            }
            if (o instanceof PointObject) {
                final int i=o.getDistance(this);
                if ((i<=mRayAbs)&&(i<dp)) {
                    PtObject=o;
                    rayp=mRay;
                    dp=i;
                }
            } else if (o instanceof PointonObject) {
                final int i=o.getDistance(this);
                if ((i<=mRayAbs)&&(i<dm)) {
                    PtOnObject=o;
                    raym=mRay;
                    dm=i;
                }
            }
        }
        if (PtObject!=null) {
            final PointObject pt=(PointObject) PtObject;
            setXYaway(pt.getX(), pt.getY(), rayp);
            if (PtObject!=CurrentMagnetObject) {
                CurrentMagnetObject=PtObject;
                CurrentMagnetRay=rayp;
                Cn.reorderConstruction();
            }
            pipe_tools.Magnet_To_HTML(this.getName(), CurrentMagnetObject.getName());
        } else if (PtOnObject!=null) {
            final PointonObject pt=(PointonObject) PtOnObject;
            if (PtOnObject!=CurrentMagnetObject) {
                CurrentMagnetObject=PtOnObject;
                CurrentMagnetRay=raym;
                Cn.reorderConstruction();
            }
            pt.project(this);
            pipe_tools.Magnet_To_HTML(this.getName(), CurrentMagnetObject.getName());
        } else {
            CurrentMagnetObject=null;
            CurrentMagnetRay=Integer.MIN_VALUE;
            if (magnetObjects.size()>0) {
                pipe_tools.Magnet_To_HTML(this.getName(), "");
            }
        }
    }

    public void setCurrentMagnetObject() {
        ConstructionObject PtOnObject=null;
        ConstructionObject PtObject=null;
        final Enumeration e=magnetObjects.elements();
        int dp=Integer.MAX_VALUE, dm=Integer.MAX_VALUE;
        int rayp=0, raym=0;
        while (e.hasMoreElements()) {
            final MagnetObj mo=(MagnetObj) e.nextElement();
            final ConstructionObject o=mo.obj();
            final int mRay=(mo.ray()>Integer.MIN_VALUE)?mo.ray()
                    :getMagnetRay();
            if (o instanceof PointObject) {
                final int i=o.getDistance(this);
                if ((i<=mRay)&&(i<dp)) {
                    PtObject=o;
                    rayp=mRay;
                    dp=i;
                }
            } else if (o instanceof PointonObject) {
                final int i=o.getDistance(this);
                if ((i<=mRay)&&(i<dm)) {
                    PtOnObject=o;
                    raym=mRay;
                    dm=i;
                }
            }
        }
        if (PtObject!=null) {
            CurrentMagnetObject=PtObject;
            CurrentMagnetRay=rayp;
        } else if (PtOnObject!=null) {
            CurrentMagnetObject=PtOnObject;
            CurrentMagnetRay=raym;
        } else {
            CurrentMagnetObject=null;
            CurrentMagnetRay=Integer.MIN_VALUE;
        }
    }

    public ConstructionObject getCurrentMagnetObject() {
        return CurrentMagnetObject;
    }

    public void followMagnetObject() {
        if (CurrentMagnetObject!=null) {
            if (CurrentMagnetObject instanceof PointObject) {
                final PointObject pt=(PointObject) CurrentMagnetObject;
                if (CurrentMagnetRay>0) {
                    setXY(pt.getX(), pt.getY());
                }
            } else if (CurrentMagnetObject instanceof PointonObject) {
                project(CurrentMagnetObject, Alpha);
            }
        }
        magnet();
    }

    @Override
    public int getDistance(final PointObject P) {
        final double d=Math.sqrt(((getX()-P.getX())*(getX()-P.getX())+(getY()-P.getY())*(getY()-P.getY())));
        return (int) Math.round(d*Cn.getPixel());
    }

    public void project(final ConstructionObject o) {
        if (!(o instanceof PointonObject)) {
            return;
        }
        ((PointonObject) o).project(this);
        if (UseAlpha) {
            AlphaValid=true;
        }
    }

    public void project(final ConstructionObject o, final double alpha) {
        ((PointonObject) o).project(this, alpha);
    }

    @Override
    public void printArgs(final XmlWriter xml) {
        updateText();
        updateMagnetObjects();
        if (Bound!=null) {
            xml.printArg("on", Bound.getName());
            if (KeepInside) {
                xml.printArg("inside", "true");
            }
        }
        if (magnetObjects.size()>0) {
            xml.printArg("magnetobjs", getMagnetObjectsString());
            xml.printArg("magnetd", ""+magnetRayExp.toString());
        }
        if (haveBoundOrder()) {
            xml.printArg("boundorder", String.valueOf(BoundOrder));
        }
        if (Fixed&&EX!=null) {
            xml.printArg("x", EX.toString());
            xml.printArg("actx", ""+X);
        } else {
            if (Bound!=null&&AlphaValid&&UseAlpha) {
                xml.printArg("alpha", ""+Alpha);
            }
            xml.printArg("x", ""+X);
        }
        if (Fixed&&EY!=null) {
            xml.printArg("y", EY.toString());
            xml.printArg("acty", ""+Y);
        } else {
            xml.printArg("y", ""+Y);
        }
        printType(xml);
        if (Is3D) {
            xml.printArg("is3D", "true");
        
	        if (Fixed3D&&EX3D!=null) {
	            xml.printArg("x3D", EX3D.toString());
	            xml.printArg("actx3D", ""+X3D);
	        } else {
	            xml.printArg("x3D", ""+X3D);
	        }
	        if (Fixed3D&&EY3D!=null) {
	            xml.printArg("y3D", EY3D.toString());
	            xml.printArg("acty3D", ""+Y3D);
	        } else {
	            xml.printArg("y3D", ""+Y3D);
	        }
	        if (Fixed3D&&EZ3D!=null) {
	            xml.printArg("z3D", EZ3D.toString());
	            xml.printArg("actz3D", ""+Z3D);
	        } else {
	            xml.printArg("z3D", ""+Z3D);
	        }
        }
        if (Fixed) {
            xml.printArg("fixed", "true");
        }
        if (Fixed3D) {
            xml.printArg("fixed3D", "true");
        }
        if (Increment>1e-4) {
            xml.printArg("increment", ""+getIncrement());
        }
    }

    public void printType(final XmlWriter xml) {
        if (Type!=0) {
            switch (Type) {
                case DIAMOND:
                    xml.printArg("shape", "diamond");
                    break;
                case CIRCLE:
                    xml.printArg("shape", "circle");
                    break;
                case DOT:
                    xml.printArg("shape", "dot");
                    break;
                case CROSS:
                    xml.printArg("shape", "cross");
                    break;
                case DCROSS:
                    xml.printArg("shape", "dcross");
                    break;
            }
        }

    }

    @Override
    public int getType() {
        return Type;
    }

    @Override
    public void setType(final int type) {
        Type=type;
    }

    public void movedBy(final ConstructionObject o) {
        MovedBy=o;
    }

    @Override
    public boolean equals(final ConstructionObject o) {
        if (!(o instanceof PointObject)||!o.valid()) {
            return false;
        }
        final PointObject p=(PointObject) o;
        return equals(X, p.X)&&equals(Y, p.Y);
    }

    @Override
    public String getEX() {
        if (EX!=null) {
            return EX.toString();
        } else {
            return ""+round(X);
        }
    }

    @Override
    public String getEY() {
        if (EY!=null) {
            return EY.toString();
        } else {
            return ""+round(Y);
        }
    }
    
    @Override
    public String getEX3D() {
        if (EX3D!=null) {
            return EX3D.toString();
        } else {
            return ""+round(X3D);
        }
    }

    @Override
    public String getEY3D() {
        if (EY3D!=null) {
            return EY3D.toString();
        } else {
            return ""+round(Y3D);
        }
    }
    
    @Override
    public String getEZ3D() {
        if (EZ3D!=null) {
            return EZ3D.toString();
        } else {
            return ""+round(Z3D);
        }
    }

    public boolean isOn(final ConstructionObject o) {
        if (Bound!=null) {
            return o==Bound;
        }
        return o.contains(this);
    }

    @Override
    public void translate() {
        if (Bound!=null) {
            Bound=Bound.getTranslation();
        } 
        else if (Is3D&Fixed3D) { 
            try {
            	setFixed(EX3D.toString(), EY3D.toString(), EZ3D.toString());
            	EX3D.translate();
                EY3D.translate();
                EZ3D.translate();
            	}
            	catch (final Exception e) {}
        }
        
        else if (Fixed) {
            try {
                setFixed(EX.toString(), EY.toString());
                EX.translate();
                EY.translate();
            } catch (final Exception e) {
                }
        }
        magnetRayExp.translate();
        translateMagnetObjects();
    }

    @Override
    public Enumeration depending() {
        super.depending();
        if (Bound!=null) {
            DL.add(Bound);
        }
        if (Fixed) {
            if (EX!=null) {
                EX.addDep(this);
            }
            if (EY!=null) {
                EY.addDep(this);
            }
        }
        if (Is3D&&Fixed3D) {
            if (EX3D!=null) {
                EX3D.addDep(this);
            }
            if (EY3D!=null) {
                EY3D.addDep(this);
            }
            if (EZ3D!=null) {
                EZ3D.addDep(this);
            }
        }
        return DL.elements();

    }

    @Override
    public void snap(final ZirkelCanvas zc) {
        final double d=zc.getGridSize()/2;
        X=Math.round(X/d)*d;
        Y=Math.round(Y/d)*d;
        updateText();
    }

    public void setHalfIncrement(final ZirkelCanvas zc) {
        final double d=zc.getGridSize()/2;
        setIncrement(d);
        validate();
    }

    @Override
    public void updateCircleDep() {
        if (Bound!=null&&Bound instanceof PrimitiveCircleObject) {
            ((PrimitiveCircleObject) Bound).addDep(this);
        }
        if (Bound!=null&&Bound instanceof PrimitiveLineObject) {
            ((PrimitiveLineObject) Bound).addDep(this);
        }
    }

    public boolean isPointOn() {
        return Bound!=null;
    }

    public boolean isPointOnOrMagnet() {
        return (Bound!=null)||(CurrentMagnetObject!=null);
    }

    public void setLaterBind(final String s) {
        LaterBind=s;
    }

    // for macro constructions :
    @Override
    public ConstructionObject copy(final double x, final double y) {
        ConstructionObject o=null;
        try {
            o=(ConstructionObject) clone();
            setTranslation(o);
            o.translateConditionals();
            o.translate();
            o.setName();
            o.updateText();
            o.setBreak(false);
            // o.setTarget(false);
            // if the target is a Point inside polygon, then try
            // to follow the mouse ! :
            if (KeepInside&&Bound!=null&&Bound instanceof AreaObject) {
                o.move(x, y);
            }
        } catch (final Exception e) {
        }
        return o;
    }

    public void computeBarycentricCoords() {
        if (Bound==null) {
            return;
        }

        if (Bound instanceof QuadricObject) {
            final QuadricObject quad=((QuadricObject) Bound);
            final PointObject A=quad.P[0];
            final PointObject B=quad.P[1];
            final PointObject C=quad.P[2];
            final double a=B.getX()-A.getX();
            final double b=C.getX()-A.getX();
            final double c=this.getX()-A.getX();
            final double d=B.getY()-A.getY();
            final double e=C.getY()-A.getY();
            final double f=this.getY()-A.getY();
            final double det=a*e-d*b;
            if (det!=0) {
                Gx=(c*e-b*f)/det;
                Gy=(a*f-c*d)/det;
                BarycentricCoordsInitialzed=true;
            }
        } else if (KeepInside&&Bound instanceof AreaObject) {
            final AreaObject area=((AreaObject) Bound);
            if (area.V.size()>2) {
                final PointObject A=(PointObject) area.V.get(0);
                final PointObject B=(PointObject) area.V.get(1);
                final PointObject C=(PointObject) area.V.get(2);
                final double a=B.getX()-A.getX();
                final double b=C.getX()-A.getX();
                final double c=this.getX()-A.getX();
                final double d=B.getY()-A.getY();
                final double e=C.getY()-A.getY();
                final double f=this.getY()-A.getY();
                final double det=a*e-d*b;
                if (det!=0) {
                    Gx=(c*e-b*f)/det;
                    Gy=(a*f-c*d)/det;
                    BarycentricCoordsInitialzed=true;
                }
            }
        }
    }

    @Override
    public void setInside(final boolean flag) {
        KeepInside=flag;
        computeBarycentricCoords();
    }

    @Override
    public boolean isInside() {
        return KeepInside;
    }

    public boolean isFixedInWindow() {
        String xstr="(windoww/(windoww-d(windoww)))*(x("+getName()+")-windowcx)+windowcx+d(windowcx)";
        String ystr="(windoww/(windoww-d(windoww)))*(y("+getName()+")-windowcy)+windowcy+d(windowcy)";
        if ((xstr.equals(getEX()))&&(ystr.equals(getEY()))) {
            return true;
        }
        ;
        return false;
    }

    @Override
    public void laterBind(final Construction c) {
        if (LaterBind.equals("")) {
            return;
        }
        final ConstructionObject o=c.find(LaterBind);
        if (o!=null&&((o instanceof PointonObject)||(o instanceof InsideObject))) {
            Bound=o;
            updateText();
            validate();
        }
        LaterBind="";
    }

    public void setAlpha(final double alpha) {
        Alpha=alpha;
        AlphaValid=true;
    }

    public void setUseAlpha(final boolean flag) {
        UseAlpha=flag;
    }

    public boolean useAlpha() {
        return UseAlpha;
    }

    public double getAlpha() {
        return Alpha;
    }

    @Override
    public void round() {
        move(round(X, ZirkelCanvas.LengthsFactor), round(Y,
                ZirkelCanvas.LengthsFactor));
    }

    /**
     * For bounded points.
     */
    @Override
    public void setKeepClose(final double x, final double y) {
        KeepClose=true;
        XcOffset=x-X;
        YcOffset=y-Y;
    }

    @Override
    public boolean canKeepClose() {
        return true;
    }

    public boolean dontUpdate() {
        return DontUpdate;
    }

    public void dontUpdate(final boolean flag) {
        DontUpdate=flag;
    }

    /**
     * Overwrite setting of default things for macro targets.
     */
    // public void setTargetDefaults ()
    // { super.setTargetDefaults();
    // Type=Cn.DefaultType;
    // }
    @Override
    public void startDrag(final double x, final double y) {
    }

    @Override
    public void dragTo(final double x, final double y) {
        clearBoundOrder();
        if ((X==x)&&(Y==y)) {
            return;
        }
        // System.out.println(getName()+" : dragTo !");
        move(x, y);
    }

    @Override
    public double getOldX() {
        return 0;
    }

    @Override
    public double getOldY() {
        return 0;
    }

    @Override
    public void setIncrement(final double inc) {
        Increment=inc;
    }

    @Override
    public double getIncrement() {
        return Increment;
    }

    @Override
    public boolean isDriverObject() {
        if (Bound!=null) {
            return true;
        }
        // if (Fixed) return false;
        return Moveable&&!Keep;
    }

    @Override
    public boolean somethingChanged() {
        return ((getX()!=LASTX)||(getY()!=LASTY));
    }

    @Override
    public void clearChanges() {
        LASTX=getX();
        LASTY=getY();
    }
    
    public void setEX3D(String s) {
        EX3D=new Expression(s, JZirkelCanvas.getCurrentZC().getConstruction(), this);
    }
}