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

273 lines
5.5 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: CircleObject.java
import java.awt.Frame;
import java.util.Enumeration;
import rene.dialogs.Warning;
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.expression.Expression;
import rene.zirkel.expression.InvalidException;
public class CircleObject extends PrimitiveCircleObject implements
MoveableObject {
protected PointObject P2;
boolean Fixed = false;
Expression E;
boolean ExpressionFailed;
boolean Ellipse = false;
public CircleObject(final Construction c, final PointObject p1,
final PointObject p2) {
super(c, p1);
P2 = p2;
validate();
updateText();
}
@Override
public String getTag() {
return "Circle";
}
@Override
public void updateText() {
if (Fixed) {
if (E == null) {
setText(text3(Global.name("text.circle.fixed"), M.getName(), P2
.getName(), "" + round(R)));
} else {
setText(text3(Global.name("text.circle.fixed"), M.getName(), P2
.getName(), "\"" + E.toString() + "\""));
}
} else {
setText(text2(Global.name("text.circle"), M.getName(), P2.getName()));
}
}
@Override
public void validate() {
super.validate();
ExpressionFailed = false;
if (!M.valid() || !P2.valid()) {
Valid = false;
return;
} else {
Valid = true;
X = M.getX();
Y = M.getY();
final double X2 = P2.getX(), Y2 = P2.getY();
// compute normalized vector in the direction of the line:
final double DX = X2 - X, DY = Y2 - Y;
R = Math.sqrt(DX * DX + DY * DY);
if (Fixed) {
if (!P2.moveableBy(this)) {
Fixed = false;
} else {
try {
double FixR = E.getValue();
if (FixR < 0) {
FixR = 0;
}
if (R < 1e-10) {
P2.move(X + FixR, Y);
} else {
P2.move(X + DX * FixR / R, Y + DY * FixR / R);
}
R = FixR;
P2.movedBy(this);
} catch (final Exception e) {
R = 0;
P2.move(X, Y);
ExpressionFailed = true;
Valid = false;
}
}
}
}
}
@Override
public void printArgs(final XmlWriter xml) {
xml.printArg("through", P2.getName());
if (Fixed && E != null) {
xml.printArg("fixed", E.toString());
}
super.printArgs(xml);
}
@Override
public boolean canFix() {
return /* M.moveableBy(this) || */P2.moveableBy(this);
}
@Override
public boolean fixed() {
return Fixed;
}
@Override
public void setFixed(final boolean flag, final String s)
throws ConstructionException {
if (!flag || s.equals("")) {
Fixed = false;
E = null;
} else {
E = new Expression(s, getConstruction(), this);
if (!E.isValid()) {
throw new ConstructionException(E.getErrorText());
}
Fixed = true;
}
updateText();
}
@Override
public boolean nearto(final int c, final int r, final ZirkelCanvas zc) {
if (ExpressionFailed && M.valid()) {
return M.nearto(c, r, zc);
}
return super.nearto(c, r, zc);
}
public boolean isValidFix() {
return E != null && E.isValid();
}
@Override
public void updateCircleDep() {
addDep(P2);
}
@Override
public void translate() {
super.translate();
P2 = (PointObject) P2.getTranslation();
try {
setFixed(Fixed, E.toString());
E.translate();
} catch (final Exception e) {
Fixed = false;
}
}
@Override
public String getStringLength() {
if (E != null) {
return E.toString();
} else {
return "" + roundDisplay(R);
}
}
@Override
public double getValue() throws ConstructionException {
if (!Valid) {
throw new InvalidException("exception.invalid");
} else {
return R;
}
}
@Override
public Enumeration depending() {
super.depending();
if (!Fixed || E == null) {
return depset(P2);
} else {
depset(P2);
final Enumeration e = E.getDepList().elements();
while (e.hasMoreElements()) {
DL.add((ConstructionObject) e.nextElement());
}
return DL.elements();
}
}
public void setP1P2(final PointObject p1, final PointObject p2) {
M = p1;
P2 = p2;
}
public PointObject getP2() {
return P2;
}
@Override
public boolean contains(final PointObject p) {
return p == P2;
}
public void dragTo(final double x, final double y) {
M.move(x1 + (x - x3), y1 + (y - y3));
P2.move(x2 + (x - x3), y2 + (y - y3));
}
@Override
public void move(final double x, final double y) {
}
public boolean moveable() {
if (!Fixed && M.moveable() && P2.moveable()) {
return true;
}
return false;
}
double x1, y1, x2, y2, x3, y3;
public void startDrag(final double x, final double y) {
x1 = M.getX();
y1 = M.getY();
x2 = P2.getX();
y2 = P2.getY();
x3 = x;
y3 = y;
}
public double getOldX() {
return 0;
}
public double getOldY() {
return 0;
}
@Override
public void snap(final ZirkelCanvas zc) {
if (moveable()) {
M.snap(zc);
P2.snap(zc);
}
}
}