UndoClearStack(&redo);

UndoClearStack(&undo);

for(int i = 0; i < SK.groupOrder.n; i++) {

Group *g = SK.GetGroup(SK.groupOrder.elem[i]);

g->Clear();

}

SK.constraint.Clear();

SK.request.Clear();

SK.group.Clear();

SK.groupOrder.Clear();

SK.style.Clear();

SK.entity.Clear();

SK.param.Clear();

Group g = {};

// And an empty group, for the first stuff the user draws.

g.visible = true;

g.name = "sketch-in-plane";

g.type = Group::Type::DRAWING_WORKPLANE;

g.subtype = Group::Subtype::WORKPLANE_BY_POINT_ORTHO;

g.order = 1;

g.predef.q = Quaternion::From(1, 0, 0, 0);

hRequest hr = Request::HREQUEST_REFERENCE_XY;

g.predef.origin = hr.entity(1);

SK.group.AddAndAssignId(&g);

SK.GetGroup(g.h)->activeWorkplane = g.h.entity(0);

return g.h;

ClearExisting();

// Our initial group, that contains the references.

Group g = {};

g.visible = true;

g.name = "#references";

g.type = Group::Type::DRAWING_3D;

g.order = 0;

g.h = Group::HGROUP_REFERENCES;

SK.group.Add(&g);

// Let's create three two-d coordinate systems, for the coordinate

// planes; these are our references, present in every sketch.

Request r = {};

r.type = Request::Type::WORKPLANE;

r.group = Group::HGROUP_REFERENCES;

r.workplane = Entity::FREE_IN_3D;

r.h = Request::HREQUEST_REFERENCE_XY;

SK.request.Add(&r);

r.h = Request::HREQUEST_REFERENCE_YZ;

SK.request.Add(&r);

r.h = Request::HREQUEST_REFERENCE_ZX;

SK.request.Add(&r);

CreateDefaultDrawingGroup();

IdList<EntityMap,EntityId> &M() { return *((IdList<EntityMap,EntityId> *)this); }

std::string &S() { return *((std::string *)this); }

bool &b() { return *((bool *)this); }

RgbaColor &c() { return *((RgbaColor *)this); }

int &d() { return *((int *)this); }

double &f() { return *((double *)this); }

uint32_t &x() { return *((uint32_t *)this); }

int i;

for(i = 0; SAVED[i].type != 0; i++) {

if(SAVED[i].type != type) continue;

int fmt = SAVED[i].fmt;

SAVEDptr *p = (SAVEDptr *)SAVED[i].ptr;

// Any items that aren't specified are assumed to be zero

if(fmt == 'S' && p->S().empty()) continue;

if(fmt == 'd' && p->d() == 0) continue;

if(fmt == 'f' && EXACT(p->f() == 0.0)) continue;

if(fmt == 'x' && p->x() == 0) continue;

fprintf(fh, "%s=", SAVED[i].desc);

switch(fmt) {

case 'S': fprintf(fh, "%s", p->S().c_str()); break;

case 'b': fprintf(fh, "%d", p->b() ? 1 : 0); break;

case 'c': fprintf(fh, "%08x", p->c().ToPackedInt()); break;

case 'd': fprintf(fh, "%d", p->d()); break;

case 'f': fprintf(fh, "%.20f", p->f()); break;

case 'x': fprintf(fh, "%08x", p->x()); break;

case 'M': {

int j;

fprintf(fh, "{\n");

for(j = 0; j < p->M().n; j++) {

EntityMap *em = &(p->M().elem[j]);

fprintf(fh, " %d %08x %d\n",

em->h.v, em->input.v, em->copyNumber);

}

fprintf(fh, "}");

break;

}

default: ssassert(false, "Unexpected value format");

}

fprintf(fh, "\n");

}

// Make sure all the entities are regenerated up to date, since they

// will be exported. We reload the linked files because that rewrites

// the linkFileRel for our possibly-new filename.

SS.ScheduleShowTW();

SS.ReloadAllImported();

SS.GenerateAll(SolveSpaceUI::Generate::ALL);

fh = ssfopen(filename, "wb");

if(!fh) {

Error("Couldn't write to file '%s'", filename.c_str());

return false;

}

fprintf(fh, "%s\n\n\n", VERSION_STRING);

int i, j;

for(i = 0; i < SK.group.n; i++) {

sv.g = SK.group.elem[i];

SaveUsingTable('g');

fprintf(fh, "AddGroup\n\n");

}

for(i = 0; i < SK.param.n; i++) {

sv.p = SK.param.elem[i];

SaveUsingTable('p');

fprintf(fh, "AddParam\n\n");

}

for(i = 0; i < SK.request.n; i++) {

sv.r = SK.request.elem[i];

SaveUsingTable('r');

fprintf(fh, "AddRequest\n\n");

}

for(i = 0; i < SK.entity.n; i++) {

(SK.entity.elem[i]).CalculateNumerical(/*forExport=*/true);

sv.e = SK.entity.elem[i];

SaveUsingTable('e');

fprintf(fh, "AddEntity\n\n");

}

for(i = 0; i < SK.constraint.n; i++) {

sv.c = SK.constraint.elem[i];

SaveUsingTable('c');

fprintf(fh, "AddConstraint\n\n");

}

for(i = 0; i < SK.style.n; i++) {

sv.s = SK.style.elem[i];

if(sv.s.h.v >= Style::FIRST_CUSTOM) {

SaveUsingTable('s');

fprintf(fh, "AddStyle\n\n");

}

}

// A group will have either a mesh or a shell, but not both; but the code

// to print either of those just does nothing if the mesh/shell is empty.

Group *g = SK.GetGroup(SK.groupOrder.elem[SK.groupOrder.n - 1]);

SMesh *m = &g->runningMesh;

for(i = 0; i < m->l.n; i++) {

STriangle *tr = &(m->l.elem[i]);

fprintf(fh, "Triangle %08x %08x "

"%.20f %.20f %.20f %.20f %.20f %.20f %.20f %.20f %.20f\n",

tr->meta.face, tr->meta.color.ToPackedInt(),

CO(tr->a), CO(tr->b), CO(tr->c));

}

SShell *s = &g->runningShell;

SSurface *srf;

for(srf = s->surface.First(); srf; srf = s->surface.NextAfter(srf)) {

fprintf(fh, "Surface %08x %08x %08x %d %d\n",

srf->h.v, srf->color.ToPackedInt(), srf->face, srf->degm, srf->degn);

for(i = 0; i <= srf->degm; i++) {

for(j = 0; j <= srf->degn; j++) {

fprintf(fh, "SCtrl %d %d %.20f %.20f %.20f Weight %20.20f\n",

i, j, CO(srf->ctrl[i][j]), srf->weight[i][j]);

}

}

STrimBy *stb;

for(stb = srf->trim.First(); stb; stb = srf->trim.NextAfter(stb)) {

fprintf(fh, "TrimBy %08x %d %.20f %.20f %.20f %.20f %.20f %.20f\n",

stb->curve.v, stb->backwards ? 1 : 0,

CO(stb->start), CO(stb->finish));

}

fprintf(fh, "AddSurface\n");

}

SCurve *sc;

for(sc = s->curve.First(); sc; sc = s->curve.NextAfter(sc)) {

fprintf(fh, "Curve %08x %d %d %08x %08x\n",

sc->h.v,

sc->isExact ? 1 : 0, sc->exact.deg,

sc->surfA.v, sc->surfB.v);

if(sc->isExact) {

for(i = 0; i <= sc->exact.deg; i++) {

fprintf(fh, "CCtrl %d %.20f %.20f %.20f Weight %.20f\n",

i, CO(sc->exact.ctrl[i]), sc->exact.weight[i]);

}

}

SCurvePt *scpt;

for(scpt = sc->pts.First(); scpt; scpt = sc->pts.NextAfter(scpt)) {

fprintf(fh, "CurvePt %d %.20f %.20f %.20f\n",

scpt->vertex ? 1 : 0, CO(scpt->p));

}

fprintf(fh, "AddCurve\n");

}

fclose(fh);

return true;

int i;

for(i = 0; SAVED[i].type != 0; i++) {

if(strcmp(SAVED[i].desc, key)==0) {

SAVEDptr *p = (SAVEDptr *)SAVED[i].ptr;

unsigned int u = 0;

switch(SAVED[i].fmt) {

case 'S': p->S() = val; break;

case 'b': p->b() = (atoi(val) != 0); break;

case 'd': p->d() = atoi(val); break;

case 'f': p->f() = atof(val); break;

case 'x': sscanf(val, "%x", &u); p->x()= u; break;

case 'c':

sscanf(val, "%x", &u);

p->c() = RgbaColor::FromPackedInt(u);

break;

case 'P':

p->S() = val;

break;

case 'M': {

// Don't clear this list! When the group gets added, it

// makes a shallow copy, so that would result in us

// freeing memory that we want to keep around. Just

// zero it out so that new memory is allocated.

p->M() = {};

for(;;) {

EntityMap em;

char line2[1024];

if (fgets(line2, (int)sizeof(line2), fh) == NULL)

break;

if(sscanf(line2, "%d %x %d", &(em.h.v), &(em.input.v),

&(em.copyNumber)) == 3)

{

p->M().Add(&em);

} else {

break;

}

}

break;

}

default: ssassert(false, "Unexpected value format");

}

break;

}

}

if(SAVED[i].type == 0) {

fileLoadError = true;

}

allConsistent = false;

fileLoadError = false;

fh = ssfopen(filename, "rb");

if(!fh) {

Error("Couldn't read from file '%s'", filename.c_str());

return false;

}

ClearExisting();

sv = {};

sv.g.scale = 1; // default is 1, not 0; so legacy files need this

Style::FillDefaultStyle(&sv.s);

char line[1024];

while(fgets(line, (int)sizeof(line), fh)) {

char *s = strchr(line, '\n');

if(s) *s = '\0';

// We should never get files with \r characters in them, but mailers

// will sometimes mangle attachments.

s = strchr(line, '\r');

if(s) *s = '\0';

if(*line == '\0') continue;

char *e = strchr(line, '=');

if(e) {

*e = '\0';

char *key = line, *val = e+1;

LoadUsingTable(key, val);

} else if(strcmp(line, "AddGroup")==0) {

// legacy files have a spurious dependency between linked groups

// and their parent groups, remove

if(sv.g.type == Group::Type::LINKED)

sv.g.opA.v = 0;

SK.group.Add(&(sv.g));

sv.g = {};

sv.g.scale = 1; // default is 1, not 0; so legacy files need this

} else if(strcmp(line, "AddParam")==0) {

// params are regenerated, but we want to preload the values

// for initial guesses

SK.param.Add(&(sv.p));

sv.p = {};

} else if(strcmp(line, "AddEntity")==0) {

// entities are regenerated

} else if(strcmp(line, "AddRequest")==0) {

SK.request.Add(&(sv.r));

sv.r = {};

} else if(strcmp(line, "AddConstraint")==0) {

SK.constraint.Add(&(sv.c));

sv.c = {};

} else if(strcmp(line, "AddStyle")==0) {

SK.style.Add(&(sv.s));

sv.s = {};

Style::FillDefaultStyle(&sv.s);

} else if(strcmp(line, VERSION_STRING)==0) {

// do nothing, version string

} else if(StrStartsWith(line, "Triangle ") ||

StrStartsWith(line, "Surface ") ||

StrStartsWith(line, "SCtrl ") ||

StrStartsWith(line, "TrimBy ") ||

StrStartsWith(line, "Curve ") ||

StrStartsWith(line, "CCtrl ") ||

StrStartsWith(line, "CurvePt ") ||

strcmp(line, "AddSurface")==0 ||

strcmp(line, "AddCurve")==0)

{

// ignore the mesh or shell, since we regenerate that

} else {

fileLoadError = true;

}

}

fclose(fh);

if(fileLoadError) {

Error("Unrecognized data in file. This file may be corrupt, or "

"from a new version of the program.");

// At least leave the program in a non-crashing state.

if(SK.group.n == 0) {

NewFile();

}

}

UpgradeLegacyData();

return true;

for(Request &r : SK.request) {

switch(r.type) {

// TTF text requests saved in versions prior to 3.0 only have two

// reference points (origin and origin plus v); version 3.0 adds two

// more points, and if we don't do anything, then they will appear

// at workplane origin, and the solver will mess up the sketch if

// it is not fully constrained.

case Request::Type::TTF_TEXT: {

IdList<Entity,hEntity> entity = {};

IdList<Param,hParam> param = {};

r.Generate(&entity, &param);

// If we didn't load all of the entities and params that this

// request would generate, then add them now, so that we can

// force them to their appropriate positions.

for(Param &p : param) {

if(SK.param.FindByIdNoOops(p.h) != NULL) continue;

SK.param.Add(&p);

}

bool allPointsExist = true;

for(Entity &e : entity) {

if(SK.entity.FindByIdNoOops(e.h) != NULL) continue;

SK.entity.Add(&e);

allPointsExist = false;

}

if(!allPointsExist) {

Entity *text = entity.FindById(r.h.entity(0));

Entity *b = entity.FindById(text->point[2]);

Entity *c = entity.FindById(text->point[3]);

ExprVector bex, cex;

text->TtfTextGetPointsExprs(&bex, &cex);

b->PointForceParamTo(bex.Eval());

c->PointForceParamTo(cex.Eval());

}

entity.Clear();

param.Clear();

}

default:

break;

}

}

SMesh *m, SShell *sh)

{

SSurface srf = {};

SCurve crv = {};

fh = ssfopen(filename, "rb");

if(!fh) return false;

le->Clear();

sv = {};

char line[1024];

while(fgets(line, (int)sizeof(line), fh)) {

char *s = strchr(line, '\n');

if(s) *s = '\0';

// We should never get files with \r characters in them, but mailers

// will sometimes mangle attachments.

s = strchr(line, '\r');

if(s) *s = '\0';

if(*line == '\0') continue;

char *e = strchr(line, '=');

if(e) {

*e = '\0';

char *key = line, *val = e+1;

LoadUsingTable(key, val);

} else if(strcmp(line, "AddGroup")==0) {

// Don't leak memory; these get allocated whether we want them

// or not.

sv.g.remap.Clear();

} else if(strcmp(line, "AddParam")==0) {

} else if(strcmp(line, "AddEntity")==0) {

le->Add(&(sv.e));

sv.e = {};

} else if(strcmp(line, "AddRequest")==0) {

} else if(strcmp(line, "AddConstraint")==0) {

} else if(strcmp(line, "AddStyle")==0) {

} else if(strcmp(line, VERSION_STRING)==0) {

} else if(StrStartsWith(line, "Triangle ")) {

STriangle tr = {};

unsigned int rgba = 0;

if(sscanf(line, "Triangle %x %x "

"%lf %lf %lf %lf %lf %lf %lf %lf %lf",

&(tr.meta.face), &rgba,

&(tr.a.x), &(tr.a.y), &(tr.a.z),

&(tr.b.x), &(tr.b.y), &(tr.b.z),

&(tr.c.x), &(tr.c.y), &(tr.c.z)) != 11) {

ssassert(false, "Unexpected Triangle format");

}

tr.meta.color = RgbaColor::FromPackedInt((uint32_t)rgba);

m->AddTriangle(&tr);

} else if(StrStartsWith(line, "Surface ")) {

unsigned int rgba = 0;

if(sscanf(line, "Surface %x %x %x %d %d",

&(srf.h.v), &rgba, &(srf.face),

&(srf.degm), &(srf.degn)) != 5) {

ssassert(false, "Unexpected Surface format");

}

srf.color = RgbaColor::FromPackedInt((uint32_t)rgba);

} else if(StrStartsWith(line, "SCtrl ")) {

int i, j;

Vector c;

double w;

if(sscanf(line, "SCtrl %d %d %lf %lf %lf Weight %lf",

&i, &j, &(c.x), &(c.y), &(c.z), &w) != 6)

{

ssassert(false, "Unexpected SCtrl format");

}

srf.ctrl[i][j] = c;

srf.weight[i][j] = w;

} else if(StrStartsWith(line, "TrimBy ")) {

STrimBy stb = {};

int backwards;

if(sscanf(line, "TrimBy %x %d %lf %lf %lf %lf %lf %lf",

&(stb.curve.v), &backwards,

&(stb.start.x), &(stb.start.y), &(stb.start.z),

&(stb.finish.x), &(stb.finish.y), &(stb.finish.z)) != 8)

{

ssassert(false, "Unexpected TrimBy format");

}

stb.backwards = (backwards != 0);

srf.trim.Add(&stb);

} else if(strcmp(line, "AddSurface")==0) {

sh->surface.Add(&srf);

srf = {};

} else if(StrStartsWith(line, "Curve ")) {

int isExact;

if(sscanf(line, "Curve %x %d %d %x %x",

&(crv.h.v),

&(isExact),

&(crv.exact.deg),

&(crv.surfA.v), &(crv.surfB.v)) != 5)

{

ssassert(false, "Unexpected Curve format");

}

crv.isExact = (isExact != 0);

} else if(StrStartsWith(line, "CCtrl ")) {

int i;

Vector c;

double w;

if(sscanf(line, "CCtrl %d %lf %lf %lf Weight %lf",

&i, &(c.x), &(c.y), &(c.z), &w) != 5)

{

ssassert(false, "Unexpected CCtrl format");

}

crv.exact.ctrl[i] = c;

crv.exact.weight[i] = w;

} else if(StrStartsWith(line, "CurvePt ")) {

SCurvePt scpt;

int vertex;

if(sscanf(line, "CurvePt %d %lf %lf %lf",

&vertex,

&(scpt.p.x), &(scpt.p.y), &(scpt.p.z)) != 4)

{

ssassert(false, "Unexpected CurvePt format");

}

scpt.vertex = (vertex != 0);

crv.pts.Add(&scpt);

} else if(strcmp(line, "AddCurve")==0) {

sh->curve.Add(&crv);

crv = {};

} else ssassert(false, "Unexpected operation");

}

fclose(fh);

return true;

{

std::vector<std::string> result;

size_t oldpos = 0, pos = 0;

while(true) {

oldpos = pos;

pos = haystack.find(needle, pos);

if(pos == std::string::npos) break;

result.push_back(haystack.substr(oldpos, pos - oldpos));

pos += needle.length();

}

if(oldpos != haystack.length() - 1)

result.push_back(haystack.substr(oldpos));

return result;

{

bool first = true;

std::string result;

for(auto &part : parts) {

if(!first) result += separator;

result += part;

first = false;

}

return result;

{

std::vector<std::string> baseParts = Split(base, PATH_SEP),

pathParts = Split(path, PATH_SEP),

resultParts;

baseParts.pop_back();

size_t common;

for(common = 0; common < baseParts.size() && common < pathParts.size(); common++) {

if(!PathEqual(baseParts[common], pathParts[common]))

break;

}

for(size_t i = common; i < baseParts.size(); i++)

resultParts.push_back("..");

resultParts.insert(resultParts.end(),

pathParts.begin() + common, pathParts.end());

return Join(resultParts, PATH_SEP);

{

std::vector<std::string> resultParts = Split(base, PATH_SEP),

pathParts = Split(path, PATH_SEP);

resultParts.pop_back();

for(auto &part : pathParts) {

if(part == ".") {

/* do nothing */

} else if(part == "..") {

ssassert(!resultParts.empty(), "Relative path pointing outside of root directory");

resultParts.pop_back();

} else {

resultParts.push_back(part);

}

}

return Join(resultParts, PATH_SEP);

{

for(size_t i = 0; i < filename.length(); i++) {

if(filename[i] == '\\')

filename[i] = '/';

}

{

std::map<std::string, std::string> linkMap;

allConsistent = false;

int i;

for(i = 0; i < SK.group.n; i++) {

Group *g = &(SK.group.elem[i]);

if(g->type != Group::Type::LINKED) continue;

if(isalpha(g->linkFile[0]) && g->linkFile[1] == ':') {

// Make sure that g->linkFileRel always contains a relative path

// in an UNIX format, even after we load an old file which had

// the path in Windows format

PathSepNormalize(g->linkFileRel);

}

g->impEntity.Clear();

g->impMesh.Clear();

g->impShell.Clear();

if(linkMap.count(g->linkFile)) {

std::string newPath = linkMap[g->linkFile];

if(!newPath.empty())

g->linkFile = newPath;

}

// In a newly created group we only have an absolute path.

if(!g->linkFileRel.empty()) {

std::string rel = PathSepUnixToPlatform(g->linkFileRel);

std::string fromRel = MakePathAbsolute(SS.saveFile, rel);

FILE *test = ssfopen(fromRel, "rb");

if(test) {

fclose(test);

// Okay, exists; update the absolute path.

g->linkFile = fromRel;

} else {

// It doesn't exist. Perhaps the file was moved but the tree wasn't, and we

// can use the absolute filename to get us back. The relative path will be

// updated below.

}

}

try_load_file:

if(LoadEntitiesFromFile(g->linkFile, &(g->impEntity), &(g->impMesh), &(g->impShell)))

{

if(!SS.saveFile.empty()) {

// Record the linked file's name relative to our filename;

// if the entire tree moves, then everything will still work

std::string rel = MakePathRelative(SS.saveFile, g->linkFile);

g->linkFileRel = PathSepPlatformToUnix(rel);

} else {

// We're not yet saved, so can't make it absolute.

// This will only be used for display purposes, as SS.saveFile

// is always nonempty when we are actually writing anything.

g->linkFileRel = g->linkFile;

}

} else if(!linkMap.count(g->linkFile)) {

switch(LocateImportedFileYesNoCancel(g->linkFileRel, canCancel)) {

case DIALOG_YES: {

std::string oldImpFile = g->linkFile;

if(!GetOpenFile(&g->linkFile, "", SlvsFileFilter)) {

if(canCancel)

return false;

break;

} else {

linkMap[oldImpFile] = g->linkFile;

goto try_load_file;

}

}

case DIALOG_NO:

linkMap[g->linkFile] = "";

/* Geometry will be pruned by GenerateAll(). */

break;

case DIALOG_CANCEL:

return false;

}

} else {

// User was already asked to and refused to locate a missing

// linked file.

}

}

return true;