void GraphicsWindow::EditControlDone(const char *s) {
HideGraphicsEditControl();
Constraint *c = SK.GetConstraint(constraintBeingEdited);
if(c->type == Constraint::COMMENT) {
SS.UndoRemember();
c->comment.strcpy(s);
return;
}
Expr *e = Expr::From(s, true);
if(e) {
SS.UndoRemember();
switch(c->type) {
case Constraint::PROJ_PT_DISTANCE:
case Constraint::PT_LINE_DISTANCE:
case Constraint::PT_FACE_DISTANCE:
case Constraint::PT_PLANE_DISTANCE: {
// The sign is not displayed to the user, but this is a signed
// distance internally. To flip the sign, the user enters a
// negative distance.
bool wasNeg = (c->valA < 0);
if(wasNeg) {
c->valA = -SS.ExprToMm(e);
} else {
c->valA = SS.ExprToMm(e);
}
break;
}
case Constraint::ANGLE:
case Constraint::LENGTH_RATIO:
// These don't get the units conversion for distance, and
// they're always positive
c->valA = fabs(e->Eval());
break;
case Constraint::DIAMETER:
c->valA = fabs(SS.ExprToMm(e));
// If displayed and edited as radius, convert back
// to diameter
if(c->disp.toggleA)
c->valA *= 2;
break;
default:
// These are always positive, and they get the units conversion.
c->valA = fabs(SS.ExprToMm(e));
break;
}
SS.MarkGroupDirty(c->group);
SS.GenerateAll();
}
}
bool TextWindow::EditControlDoneForView(const char *s) {
switch(edit.meaning) {
case Edit::VIEW_SCALE: {
Expr *e = Expr::From(s, /*popUpError=*/true);
if(e) {
double v = e->Eval() / SS.MmPerUnit();
if(v > LENGTH_EPS) {
SS.GW.scale = v;
} else {
Error(_("Scale cannot be zero or negative."));
}
}
break;
}
case Edit::VIEW_ORIGIN: {
Vector pt;
if(sscanf(s, "%lf, %lf, %lf", &pt.x, &pt.y, &pt.z) == 3) {
pt = pt.ScaledBy(SS.MmPerUnit());
SS.GW.offset = pt.ScaledBy(-1);
} else {
Error(_("Bad format: specify x, y, z"));
}
break;
}
case Edit::VIEW_PROJ_RIGHT:
case Edit::VIEW_PROJ_UP: {
Vector pt;
if(sscanf(s, "%lf, %lf, %lf", &pt.x, &pt.y, &pt.z) != 3) {
Error(_("Bad format: specify x, y, z"));
break;
}
if(edit.meaning == Edit::VIEW_PROJ_RIGHT) {
SS.GW.projRight = pt;
SS.GW.NormalizeProjectionVectors();
edit.meaning = Edit::VIEW_PROJ_UP;
HideEditControl();
ShowEditControl(10, ssprintf("%.3f, %.3f, %.3f", CO(SS.GW.projUp)),
editControl.halfRow + 2);
edit.showAgain = true;
} else {
SS.GW.projUp = pt;
SS.GW.NormalizeProjectionVectors();
}
break;
}
default:
return false;
}
return true;
}
bool TextWindow::EditControlDoneForPaste(char *s) {
Expr *e;
switch(edit.meaning) {
case EDIT_PASTE_TIMES_REPEATED: {
e = Expr::From(s, true);
if(!e) break;
int v = (int)e->Eval();
if(v > 0) {
shown.paste.times = v;
} else {
Error("Number of copies to paste must be at least one.");
}
break;
}
case EDIT_PASTE_ANGLE:
e = Expr::From(s, true);
if(!e) break;
shown.paste.theta = WRAP_SYMMETRIC((e->Eval())*PI/180, 2*PI);
break;
case EDIT_PASTE_SCALE: {
e = Expr::From(s, true);
double v = e->Eval();
if(fabs(v) > 1e-6) {
shown.paste.scale = v;
} else {
Error("Scale cannot be zero.");
}
break;
}
default:
return false;
}
return true;
}
void run_the_VM() {
assert(! bootstrapping, "don't get screwed again by this");
Memory->scavenge();
SignalInterface::initialize();
initHProfiler();
IntervalTimer::start_all();
ResourceMark mark;
InteractiveScanner scanner;
VMScanner = &scanner;
resetTerminal();
if (startUpSelfFile) {
ResourceMark m;
FileScanner scnr(startUpSelfFile);
if (scnr.fileError) {
fatalNoMenu1("Couldn't read file %s!\n\n", startUpSelfFile);
} else {
lprintf("Reading %s...", scnr.fileName());
(void) evalExpressions(&scnr);
lprintf("done\n");
}
}
// After reading a snapshot we need to evaluate the snapshot actions.
if (postReadSnapshot) {
postReadSnapshot = false;
eval("snapshotAction postRead", "<postRead Snapshot>");
}
// The read-eval-print loop
for (;;) {
ResourceMark m;
fint line, len;
const char* source = NULL;
Parser parser(VMScanner, false);
resetTerminal();
VMScanner->start_line("VM# ");
processes->idle = true;
if (VMScanner->is_done())
break;
processes->idle = false;
Expr* e = parser.readExpr(line, source, len); // dont fail
if (e) {
preservedObj x(e);
oop res = e->Eval(true, false, true);
assert(currentProcess->isClean(), "vm process should be clean now");
if (res == badOop) {
VMScanner->reset();
clearerr(stdin); // don't get hung on ^D
}
}
if (Memory->needs_scavenge()) Memory->scavenge();
}
lprintf("\n");
# if TARGET_IS_PROFILED
lprintf("Writing profile statistics...\n");
# endif
clearerr(stdin);
OS::handle_suspend_and_resume(true); // make sure stdin is in normal mode
OS::terminate(0);
}
bool TextWindow::EditControlDoneForConfiguration(const char *s) {
switch(edit.meaning) {
case EDIT_LIGHT_INTENSITY:
SS.lightIntensity[edit.i] = min(1, max(0, atof(s)));
InvalidateGraphics();
break;
case EDIT_LIGHT_DIRECTION: {
double x, y, z;
if(sscanf(s, "%lf, %lf, %lf", &x, &y, &z)==3) {
SS.lightDir[edit.i] = Vector::From(x, y, z);
} else {
Error("Bad format: specify coordinates as x, y, z");
}
InvalidateGraphics();
break;
}
case EDIT_COLOR: {
Vector rgb;
if(sscanf(s, "%lf, %lf, %lf", &rgb.x, &rgb.y, &rgb.z)==3) {
rgb = rgb.ClampWithin(0, 1);
SS.modelColor[edit.i] = RGBf(rgb.x, rgb.y, rgb.z);
} else {
Error("Bad format: specify color as r, g, b");
}
break;
}
case EDIT_CHORD_TOLERANCE: {
SS.chordTol = min(10, max(0.1, atof(s)));
SS.GenerateAll(0, INT_MAX);
break;
}
//RT New stuff
case EDIT_RENDERDETAIL: {
SS.renderDetailWhenSaving = atof(s);
if (SS.renderDetailWhenSaving) SS.GW.scaleWin =SS.renderDetailWhenSaving;
SS.GenerateAll(0, INT_MAX);
break;
}
//RT End stuff
case EDIT_MAX_SEGMENTS: {
SS.maxSegments = min(1000, max(7, atoi(s)));
SS.GenerateAll(0, INT_MAX);
break;
}
case EDIT_CAMERA_TANGENT: {
SS.cameraTangent = (min(2, max(0, atof(s))))/1000.0;
if(!SS.usePerspectiveProj) {
Message("The perspective factor will have no effect until you "
"enable View -> Use Perspective Projection.");
}
InvalidateGraphics();
break;
}
case EDIT_GRID_SPACING: {
SS.gridSpacing = (float)min(1e4, max(1e-3, SS.StringToMm(s)));
InvalidateGraphics();
break;
}
case EDIT_DIGITS_AFTER_DECIMAL: {
int v = atoi(s);
if(v < 0 || v > 8) {
Error("Specify between 0 and 8 digits after the decimal.");
} else {
SS.SetUnitDigitsAfterDecimal(v);
}
InvalidateGraphics();
break;
}
case EDIT_EXPORT_SCALE: {
Expr *e = Expr::From(s, true);
if(e) {
double ev = e->Eval();
if(fabs(ev) < 0.001 || isnan(ev)) {
Error("Export scale must not be zero!");
} else {
SS.exportScale = (float)ev;
}
}
break;
}
case EDIT_EXPORT_OFFSET: {
Expr *e = Expr::From(s, true);
if(e) {
double ev = SS.ExprToMm(e);
if(isnan(ev) || ev < 0) {
Error("Cutter radius offset must not be negative!");
} else {
SS.exportOffset = (float)ev;
}
}
break;
}
case EDIT_CANVAS_SIZE: {
Expr *e = Expr::From(s, true);
if(!e) {
break;
}
float d = (float)SS.ExprToMm(e);
switch(edit.i) {
case 0: SS.exportMargin.left = d; break;
case 1: SS.exportMargin.right = d; break;
case 2: SS.exportMargin.bottom = d; break;
case 3: SS.exportMargin.top = d; break;
case 10: SS.exportCanvas.width = d; break;
case 11: SS.exportCanvas.height = d; break;
case 12: SS.exportCanvas.dx = d; break;
case 13: SS.exportCanvas.dy = d; break;
}
break;
}
case EDIT_G_CODE_DEPTH: {
Expr *e = Expr::From(s, true);
if(e) SS.gCode.depth = (float)SS.ExprToMm(e);
break;
}
case EDIT_G_CODE_PASSES: {
Expr *e = Expr::From(s, true);
if(e) SS.gCode.passes = (int)(e->Eval());
SS.gCode.passes = max(1, min(1000, SS.gCode.passes));
break;
}
case EDIT_G_CODE_FEED: {
Expr *e = Expr::From(s, true);
if(e) SS.gCode.feed = (float)SS.ExprToMm(e);
break;
}
case EDIT_G_CODE_PLUNGE_FEED: {
Expr *e = Expr::From(s, true);
if(e) SS.gCode.plungeFeed = (float)SS.ExprToMm(e);
break;
}
default: return false;
}
return true;
}
Expr *Expr::FoldConstants(void) {
Expr *n = AllocExpr();
*n = *this;
int c = Children();
if(c >= 1) n->a = a->FoldConstants();
if(c >= 2) n->b = b->FoldConstants();
switch(op) {
case PARAM_PTR:
case PARAM:
case CONSTANT:
break;
case MINUS:
case TIMES:
case DIV:
case PLUS:
// If both ops are known, then we can evaluate immediately
if(n->a->op == CONSTANT && n->b->op == CONSTANT) {
double nv = n->Eval();
n->op = CONSTANT;
n->v = nv;
break;
}
// x + 0 = 0 + x = x
if(op == PLUS && n->b->op == CONSTANT && Tol(n->b->v, 0)) {
*n = *(n->a); break;
}
if(op == PLUS && n->a->op == CONSTANT && Tol(n->a->v, 0)) {
*n = *(n->b); break;
}
// 1*x = x*1 = x
if(op == TIMES && n->b->op == CONSTANT && Tol(n->b->v, 1)) {
*n = *(n->a); break;
}
if(op == TIMES && n->a->op == CONSTANT && Tol(n->a->v, 1)) {
*n = *(n->b); break;
}
// 0*x = x*0 = 0
if(op == TIMES && n->b->op == CONSTANT && Tol(n->b->v, 0)) {
n->op = CONSTANT; n->v = 0; break;
}
if(op == TIMES && n->a->op == CONSTANT && Tol(n->a->v, 0)) {
n->op = CONSTANT; n->v = 0; break;
}
break;
case SQRT:
case SQUARE:
case NEGATE:
case SIN:
case COS:
case ASIN:
case ACOS:
if(n->a->op == CONSTANT) {
double nv = n->Eval();
n->op = CONSTANT;
n->v = nv;
}
break;
default: oops();
}
return n;
}
//-----------------------------------------------------------------------------
// The edit control is visible, and the user just pressed enter.
//-----------------------------------------------------------------------------
void TextWindow::EditControlDone(const char *s) {
edit.showAgain = false;
switch(edit.meaning) {
case EDIT_TIMES_REPEATED: {
Expr *e = Expr::From(s, true);
if(e) {
SS.UndoRemember();
double ev = e->Eval();
if((int)ev < 1) {
Error("Can't repeat fewer than 1 time.");
break;
}
if((int)ev > 999) {
Error("Can't repeat more than 999 times.");
break;
}
Group *g = SK.GetGroup(edit.group);
g->valA = ev;
if(g->type == Group::ROTATE) {
int i, c = 0;
for(i = 0; i < SK.constraint.n; i++) {
if(SK.constraint.elem[i].group.v == g->h.v) c++;
}
// If the group does not contain any constraints, then
// set the numerical guess to space the copies uniformly
// over one rotation. Don't touch the guess if we're
// already constrained, because that would break
// convergence.
if(c == 0) {
double copies = (g->skipFirst) ? (ev + 1) : ev;
SK.GetParam(g->h.param(3))->val = PI/(2*copies);
}
}
SS.MarkGroupDirty(g->h);
SS.later.generateAll = true;
}
break;
}
case EDIT_GROUP_NAME: {
if(!StringAllPrintable(s) || !*s) {
Error("Invalid characters. Allowed are: A-Z a-z 0-9 _ -");
} else {
SS.UndoRemember();
Group *g = SK.GetGroup(edit.group);
g->name.strcpy(s);
}
break;
}
case EDIT_GROUP_SCALE: {
Expr *e = Expr::From(s, true);
if(e) {
double ev = e->Eval();
if(fabs(ev) < 1e-6) {
Error("Scale cannot be zero.");
} else {
Group *g = SK.GetGroup(edit.group);
g->scale = ev;
SS.MarkGroupDirty(g->h);
SS.later.generateAll = true;
}
}
break;
}
case EDIT_GROUP_COLOR: {
Vector rgb;
if(sscanf(s, "%lf, %lf, %lf", &rgb.x, &rgb.y, &rgb.z)==3) {
rgb = rgb.ClampWithin(0, 1);
Group *g = SK.group.FindByIdNoOops(SS.TW.shown.group);
if(!g) break;
g->color = RGBf(rgb.x, rgb.y, rgb.z);
SS.MarkGroupDirty(g->h);
SS.later.generateAll = true;
SS.GW.ClearSuper();
} else {
Error("Bad format: specify color as r, g, b");
}
break;
}
case EDIT_TTF_TEXT: {
SS.UndoRemember();
Request *r = SK.request.FindByIdNoOops(edit.request);
if(r) {
r->str.strcpy(s);
SS.MarkGroupDirty(r->group);
SS.later.generateAll = true;
}
break;
}
case EDIT_STEP_DIM_FINISH: {
Expr *e = Expr::From(s, true);
if(!e) {
break;
}
if(shown.dimIsDistance) {
shown.dimFinish = SS.ExprToMm(e);
} else {
shown.dimFinish = e->Eval();
}
break;
}
case EDIT_STEP_DIM_STEPS:
shown.dimSteps = min(300, max(1, atoi(s)));
break;
case EDIT_TANGENT_ARC_RADIUS: {
Expr *e = Expr::From(s, true);
if(!e) break;
if(e->Eval() < LENGTH_EPS) {
Error("Radius cannot be zero or negative.");
break;
}
SS.tangentArcRadius = SS.ExprToMm(e);
break;
}
default: {
int cnt = 0;
if(EditControlDoneForStyles(s)) cnt++;
if(EditControlDoneForConfiguration(s)) cnt++;
if(EditControlDoneForPaste(s)) cnt++;
if(EditControlDoneForView(s)) cnt++;
if(cnt > 1) {
// The identifiers were somehow assigned not uniquely?
oops();
}
break;
}
}
InvalidateGraphics();
SS.later.showTW = true;
if(!edit.showAgain) {
HideEditControl();
edit.meaning = EDIT_NOTHING;
}
}
bool TextWindow::EditControlDoneForStyles(const char *str) {
Style *s;
switch(edit.meaning) {
case EDIT_STYLE_TEXT_HEIGHT:
case EDIT_STYLE_WIDTH: {
SS.UndoRemember();
s = Style::Get(edit.style);
double v;
int units = (edit.meaning == EDIT_STYLE_TEXT_HEIGHT) ?
s->textHeightAs : s->widthAs;
if(units == Style::UNITS_AS_MM) {
v = SS.StringToMm(str);
} else {
v = atof(str);
}
v = max(0, v);
if(edit.meaning == EDIT_STYLE_TEXT_HEIGHT) {
s->textHeight = v;
} else {
s->width = v;
}
break;
}
case EDIT_STYLE_TEXT_ANGLE:
SS.UndoRemember();
s = Style::Get(edit.style);
s->textAngle = WRAP_SYMMETRIC(atof(str), 360);
break;
case EDIT_BACKGROUND_COLOR:
case EDIT_STYLE_FILL_COLOR:
case EDIT_STYLE_COLOR: {
Vector rgb;
if(sscanf(str, "%lf, %lf, %lf", &rgb.x, &rgb.y, &rgb.z)==3) {
rgb = rgb.ClampWithin(0, 1);
if(edit.meaning == EDIT_STYLE_COLOR) {
SS.UndoRemember();
s = Style::Get(edit.style);
s->color = RGBf(rgb.x, rgb.y, rgb.z);
} else if(edit.meaning == EDIT_STYLE_FILL_COLOR) {
SS.UndoRemember();
s = Style::Get(edit.style);
s->fillColor = RGBf(rgb.x, rgb.y, rgb.z);
} else {
SS.backgroundColor = RGBf(rgb.x, rgb.y, rgb.z);
}
} else {
Error("Bad format: specify color as r, g, b");
}
break;
}
case EDIT_STYLE_NAME:
if(!StringAllPrintable(str) || !*str) {
Error("Invalid characters. Allowed are: A-Z a-z 0-9 _ -");
} else {
SS.UndoRemember();
s = Style::Get(edit.style);
s->name.strcpy(str);
}
break;
case EDIT_BACKGROUND_IMG_SCALE: {
Expr *e = Expr::From(str, true);
if(e) {
double ev = e->Eval();
if(ev < 0.001 || isnan(ev)) {
Error("Scale must not be zero or negative!");
} else {
SS.bgImage.scale = ev / SS.MmPerUnit();
}
}
break;
}
default: return false;
}
return true;
}
