Solvespace

1
//-----------------------------------------------------------------------------
2
// For the configuration screen, setup items that are not specific to the
3
// file being edited right now.
4
//
5
// Copyright 2008-2013 Jonathan Westhues.
6
//-----------------------------------------------------------------------------
7
#include "solvespace.h"
8
#if defined(_OPENMP)
9
#include <omp.h>
10
#endif
11

12
void TextWindow::ScreenChangeColor(int link, uint32_t v) {
13
    SS.TW.ShowEditControlWithColorPicker(13, SS.modelColor[v]);
14

15
    SS.TW.edit.meaning = Edit::COLOR;
16
    SS.TW.edit.i = v;
17
}
18

19
void TextWindow::ScreenChangeChordTolerance(int link, uint32_t v) {
20
    SS.TW.ShowEditControl(3, ssprintf("%lg", SS.chordTol));
21
    SS.TW.edit.meaning = Edit::CHORD_TOLERANCE;
22
    SS.TW.edit.i = 0;
23
}
24

25
void TextWindow::ScreenChangeMaxSegments(int link, uint32_t v) {
26
    SS.TW.ShowEditControl(3, ssprintf("%d", SS.maxSegments));
27
    SS.TW.edit.meaning = Edit::MAX_SEGMENTS;
28
    SS.TW.edit.i = 0;
29
}
30

31
void TextWindow::ScreenChangeExportChordTolerance(int link, uint32_t v) {
32
    SS.TW.ShowEditControl(3, ssprintf("%lg", SS.exportChordTol));
33
    SS.TW.edit.meaning = Edit::CHORD_TOLERANCE;
34
    SS.TW.edit.i = 1;
35
}
36

37
void TextWindow::ScreenChangeExportMaxSegments(int link, uint32_t v) {
38
    SS.TW.ShowEditControl(3, ssprintf("%d", SS.exportMaxSegments));
39
    SS.TW.edit.meaning = Edit::MAX_SEGMENTS;
40
    SS.TW.edit.i = 1;
41
}
42

43
void TextWindow::ScreenChangeGridSpacing(int link, uint32_t v) {
44
    SS.TW.ShowEditControl(3, SS.MmToString(SS.gridSpacing, true));
45
    SS.TW.edit.meaning = Edit::GRID_SPACING;
46
}
47

48
void TextWindow::ScreenChangeDigitsAfterDecimal(int link, uint32_t v) {
49
    SS.TW.ShowEditControl(14, ssprintf("%d", SS.UnitDigitsAfterDecimal()));
50
    SS.TW.edit.meaning = Edit::DIGITS_AFTER_DECIMAL;
51
}
52

53
void TextWindow::ScreenChangeDigitsAfterDecimalDegree(int link, uint32_t v) {
54
    SS.TW.ShowEditControl(14, ssprintf("%d", SS.afterDecimalDegree));
55
    SS.TW.edit.meaning = Edit::DIGITS_AFTER_DECIMAL_DEGREE;
56
}
57

58
void TextWindow::ScreenChangeUseSIPrefixes(int link, uint32_t v) {
59
    SS.useSIPrefixes = !SS.useSIPrefixes;
60
    SS.GW.Invalidate();
61
}
62

63
void TextWindow::ScreenChangeExportScale(int link, uint32_t v) {
64
    SS.TW.ShowEditControl(5, ssprintf("%.3f", (double)SS.exportScale));
65
    SS.TW.edit.meaning = Edit::EXPORT_SCALE;
66
}
67

68
void TextWindow::ScreenChangeExportOffset(int link, uint32_t v) {
69
    SS.TW.ShowEditControl(3, SS.MmToString(SS.exportOffset, true));
70
    SS.TW.edit.meaning = Edit::EXPORT_OFFSET;
71
}
72

73
void TextWindow::ScreenChangeArcDimDefault(int link, uint32_t v) {
74
    SS.arcDimDefaultDiameter = !SS.arcDimDefaultDiameter;
75
}
76

77
void TextWindow::ScreenChangeShowFullFilePath(int link, uint32_t v) {
78
    SS.showFullFilePath = !SS.showFullFilePath;
79
    SS.UpdateWindowTitles();
80
}
81

82
void TextWindow::ScreenChangeFixExportColors(int link, uint32_t v) {
83
    SS.fixExportColors = !SS.fixExportColors;
84
}
85

86
void TextWindow::ScreenChangeExportBackgroundColor(int link, uint32_t v) {
87
    SS.exportBackgroundColor = !SS.exportBackgroundColor;
88
}
89

90
void TextWindow::ScreenChangeBackFaces(int link, uint32_t v) {
91
    SS.drawBackFaces = !SS.drawBackFaces;
92
    SS.GW.Invalidate(/*clearPersistent=*/true);
93
}
94

95
void TextWindow::ScreenChangeTurntableNav(int link, uint32_t v) {
96
    SS.turntableNav = !SS.turntableNav;
97
    if(SS.turntableNav) {
98
        // If turntable nav is being turned on, align view so Z is vertical
99
        SS.GW.AnimateOnto(Quaternion::From(Vector::From(-1, 0, 0), Vector::From(0, 0, 1)),
100
                          SS.GW.offset);
101
    }
102
}
103

104
void TextWindow::ScreenChangeCameraNav(int link, uint32_t v) {
105
    SS.cameraNav = !SS.cameraNav;
106
}
107

108
void TextWindow::ScreenChangeImmediatelyEditDimension(int link, uint32_t v) {
109
    SS.immediatelyEditDimension = !SS.immediatelyEditDimension;
110
    SS.GW.Invalidate(/*clearPersistent=*/true);
111
}
112

113
void TextWindow::ScreenChangeShowContourAreas(int link, uint32_t v) {
114
    SS.showContourAreas = !SS.showContourAreas;
115
    SS.GW.Invalidate();
116
}
117

118
void TextWindow::ScreenChangeCheckClosedContour(int link, uint32_t v) {
119
    SS.checkClosedContour = !SS.checkClosedContour;
120
    SS.GW.Invalidate();
121
}
122

123
void TextWindow::ScreenChangeAutomaticLineConstraints(int link, uint32_t v) {
124
    SS.automaticLineConstraints = !SS.automaticLineConstraints;
125
    SS.GW.Invalidate();
126
}
127

128
void TextWindow::ScreenChangeShadedTriangles(int link, uint32_t v) {
129
    SS.exportShadedTriangles = !SS.exportShadedTriangles;
130
    SS.GW.Invalidate();
131
}
132

133
void TextWindow::ScreenChangePwlCurves(int link, uint32_t v) {
134
    SS.exportPwlCurves = !SS.exportPwlCurves;
135
    SS.GW.Invalidate();
136
}
137

138
void TextWindow::ScreenChangeCanvasSizeAuto(int link, uint32_t v) {
139
    if(link == 't') {
140
        SS.exportCanvasSizeAuto = true;
141
    } else {
142
        SS.exportCanvasSizeAuto = false;
143
    }
144
    SS.GW.Invalidate();
145
}
146

147
void TextWindow::ScreenChangeCanvasSize(int link, uint32_t v) {
148
    double d;
149
    switch(v) {
150
        case  0: d = SS.exportMargin.left;      break;
151
        case  1: d = SS.exportMargin.right;     break;
152
        case  2: d = SS.exportMargin.bottom;    break;
153
        case  3: d = SS.exportMargin.top;       break;
154

155
        case 10: d = SS.exportCanvas.width;     break;
156
        case 11: d = SS.exportCanvas.height;    break;
157
        case 12: d = SS.exportCanvas.dx;        break;
158
        case 13: d = SS.exportCanvas.dy;        break;
159

160
        default: return;
161
    }
162
    int col = 13;
163
    if(v < 10) col = 11;
164
    SS.TW.ShowEditControl(col, SS.MmToString(d, true));
165
    SS.TW.edit.meaning = Edit::CANVAS_SIZE;
166
    SS.TW.edit.i = v;
167
}
168

169
void TextWindow::ScreenChangeGCodeParameter(int link, uint32_t v) {
170
    std::string buf;
171
    switch(link) {
172
        case 'd':
173
            SS.TW.edit.meaning = Edit::G_CODE_DEPTH;
174
            buf += SS.MmToString(SS.gCode.depth, true);
175
            break;
176

177
        case 'h':
178
            SS.TW.edit.meaning = Edit::G_CODE_SAFE_HEIGHT;
179
            buf += SS.MmToString(SS.gCode.safeHeight, true);
180
            break;
181

182
        case 's':
183
            SS.TW.edit.meaning = Edit::G_CODE_PASSES;
184
            buf += std::to_string(SS.gCode.passes);
185
            break;
186

187
        case 'F':
188
            SS.TW.edit.meaning = Edit::G_CODE_FEED;
189
            buf += SS.MmToString(SS.gCode.feed, true);
190
            break;
191

192
        case 'P':
193
            SS.TW.edit.meaning = Edit::G_CODE_PLUNGE_FEED;
194
            buf += SS.MmToString(SS.gCode.plungeFeed, true);
195
            break;
196
    }
197
    SS.TW.ShowEditControl(14, buf);
198
}
199

200
void TextWindow::ScreenChangeAutosaveInterval(int link, uint32_t v) {
201
    SS.TW.ShowEditControl(3, std::to_string(SS.autosaveInterval));
202
    SS.TW.edit.meaning = Edit::AUTOSAVE_INTERVAL;
203
}
204

205
void TextWindow::ScreenChangeFindConstraintTimeout(int link, uint32_t v) {
206
    SS.TW.ShowEditControl(3, std::to_string(SS.timeoutRedundantConstr));
207
    SS.TW.edit.meaning = Edit::FIND_CONSTRAINT_TIMEOUT;
208
}
209

210
void TextWindow::ShowConfiguration() {
211
    int i;
212
    Printf(true, "%Ft user color (r, g, b)");
213

214
    for(i = 0; i < SS.MODEL_COLORS; i++) {
215
        Printf(false, "%Bp   #%d:  %Bz  %Bp  (%@, %@, %@) %f%D%Ll%Fl[change]%E",
216
            (i & 1) ? 'd' : 'a',
217
            i, &SS.modelColor[i],
218
            (i & 1) ? 'd' : 'a',
219
            SS.modelColor[i].redF(),
220
            SS.modelColor[i].greenF(),
221
            SS.modelColor[i].blueF(),
222
            &ScreenChangeColor, i);
223
    }
224

225
    Printf(false, "");
226
    Printf(false, "%Ft chord tolerance (in percents)%E");
227
    Printf(false, "%Ba   %@ %% %Fl%Ll%f%D[change]%E; %@ mm, %d triangles",
228
        SS.chordTol,
229
        &ScreenChangeChordTolerance, 0, SS.chordTolCalculated,
230
        SK.GetGroup(SS.GW.activeGroup)->displayMesh.l.n);
231
    Printf(false, "%Ft max piecewise linear segments%E");
232
    Printf(false, "%Ba   %d %Fl%Ll%f[change]%E",
233
        SS.maxSegments,
234
        &ScreenChangeMaxSegments);
235

236
    Printf(false, "");
237
    Printf(false, "%Ft export chord tolerance (in mm)%E");
238
    Printf(false, "%Ba   %@ %Fl%Ll%f%D[change]%E",
239
        SS.exportChordTol,
240
        &ScreenChangeExportChordTolerance, 0);
241
    Printf(false, "%Ft export max piecewise linear segments%E");
242
    Printf(false, "%Ba   %d %Fl%Ll%f[change]%E",
243
        SS.exportMaxSegments,
244
        &ScreenChangeExportMaxSegments);
245

246
    Printf(false, "%Ft snap grid spacing%E");
247
    Printf(false, "%Ba   %s %Fl%Ll%f%D[change]%E",
248
        SS.MmToString(SS.gridSpacing).c_str(),
249
        &ScreenChangeGridSpacing, 0);
250

251
    Printf(false, "");
252
    Printf(false, "%Ft digits after decimal point to show%E");
253
    Printf(false, "%Ba%Ft   distances: %Fd%d %Fl%Ll%f%D[change]%E (e.g. '%s')",
254
        SS.UnitDigitsAfterDecimal(),
255
        &ScreenChangeDigitsAfterDecimal, 0,
256
        SS.MmToString(SS.StringToMm("1.23456789")).c_str());
257
    Printf(false, "%Bd%Ft   angles:    %Fd%d %Fl%Ll%f%D[change]%E (e.g. '%s')",
258
        SS.afterDecimalDegree,
259
        &ScreenChangeDigitsAfterDecimalDegree, 0,
260
        SS.DegreeToString(1.23456789).c_str());
261
    Printf(false, "  %Fd%f%Ll%s  use SI prefixes for distances%E",
262
        &ScreenChangeUseSIPrefixes,
263
        SS.useSIPrefixes ? CHECK_TRUE : CHECK_FALSE);
264

265
    Printf(false, "");
266
    Printf(false, "%Ft export scale factor (1:1=mm, 1:25.4=inch)");
267
    Printf(false, "%Ba   1:%# %Fl%Ll%f%D[change]%E",
268
        (double)SS.exportScale,
269
        &ScreenChangeExportScale, 0);
270
    Printf(false, "%Ft cutter radius offset (0=no offset) ");
271
    Printf(false, "%Ba   %s %Fl%Ll%f%D[change]%E",
272
        SS.MmToString(SS.exportOffset).c_str(),
273
        &ScreenChangeExportOffset, 0);
274

275
    Printf(false, "");
276
    Printf(false, "  %Fd%f%Ll%s  export shaded 2d triangles%E",
277
        &ScreenChangeShadedTriangles,
278
        SS.exportShadedTriangles ? CHECK_TRUE : CHECK_FALSE);
279
    if(fabs(SS.exportOffset) > LENGTH_EPS) {
280
        Printf(false, "  %Fd%s  curves as piecewise linear%E "
281
                      "(since cutter radius is not zero)", CHECK_TRUE);
282
    } else {
283
        Printf(false, "  %Fd%f%Ll%s  export curves as piecewise linear%E",
284
            &ScreenChangePwlCurves,
285
            SS.exportPwlCurves ? CHECK_TRUE : CHECK_FALSE);
286
    }
287
    Printf(false, "  %Fd%f%Ll%s  fix white exported lines%E",
288
        &ScreenChangeFixExportColors,
289
        SS.fixExportColors ? CHECK_TRUE : CHECK_FALSE);
290
    Printf(false, "  %Fd%f%Ll%s  export background color%E",
291
        &ScreenChangeExportBackgroundColor,
292
        SS.exportBackgroundColor ? CHECK_TRUE : CHECK_FALSE);
293

294
    Printf(false, "");
295
    Printf(false, "%Ft export canvas size:  "
296
                  "%f%Fd%Lf%s fixed%E  "
297
                  "%f%Fd%Lt%s auto%E",
298
        &ScreenChangeCanvasSizeAuto,
299
        !SS.exportCanvasSizeAuto ? RADIO_TRUE : RADIO_FALSE,
300
        &ScreenChangeCanvasSizeAuto,
301
        SS.exportCanvasSizeAuto ? RADIO_TRUE : RADIO_FALSE);
302

303
    if(SS.exportCanvasSizeAuto) {
304
        Printf(false, "%Ft (by margins around exported geometry)");
305
        Printf(false, "%Ba%Ft   left:   %Fd%s %Fl%Ll%f%D[change]%E",
306
            SS.MmToString(SS.exportMargin.left).c_str(), &ScreenChangeCanvasSize, 0);
307
        Printf(false, "%Bd%Ft   right:  %Fd%s %Fl%Ll%f%D[change]%E",
308
            SS.MmToString(SS.exportMargin.right).c_str(), &ScreenChangeCanvasSize, 1);
309
        Printf(false, "%Ba%Ft   bottom: %Fd%s %Fl%Ll%f%D[change]%E",
310
            SS.MmToString(SS.exportMargin.bottom).c_str(), &ScreenChangeCanvasSize, 2);
311
        Printf(false, "%Bd%Ft   top:    %Fd%s %Fl%Ll%f%D[change]%E",
312
            SS.MmToString(SS.exportMargin.top).c_str(), &ScreenChangeCanvasSize, 3);
313
    } else {
314
        Printf(false, "%Ft (by absolute dimensions and offsets)");
315
        Printf(false, "%Ba%Ft   width:    %Fd%s %Fl%Ll%f%D[change]%E",
316
            SS.MmToString(SS.exportCanvas.width).c_str(), &ScreenChangeCanvasSize, 10);
317
        Printf(false, "%Bd%Ft   height:   %Fd%s %Fl%Ll%f%D[change]%E",
318
            SS.MmToString(SS.exportCanvas.height).c_str(), &ScreenChangeCanvasSize, 11);
319
        Printf(false, "%Ba%Ft   offset x: %Fd%s %Fl%Ll%f%D[change]%E",
320
            SS.MmToString(SS.exportCanvas.dx).c_str(), &ScreenChangeCanvasSize, 12);
321
        Printf(false, "%Bd%Ft   offset y: %Fd%s %Fl%Ll%f%D[change]%E",
322
            SS.MmToString(SS.exportCanvas.dy).c_str(), &ScreenChangeCanvasSize, 13);
323
    }
324

325
    Printf(false, "");
326
    Printf(false, "%Ft exported g code parameters");
327
    Printf(false, "%Ba%Ft   depth:     %Fd%s %Fl%Ld%f[change]%E",
328
        SS.MmToString(SS.gCode.depth).c_str(), &ScreenChangeGCodeParameter);
329
    Printf(false, "%Bd%Ft   passes:    %Fd%d %Fl%Ls%f[change]%E",
330
        SS.gCode.passes, &ScreenChangeGCodeParameter);
331
    Printf(false, "%Ba%Ft   feed:      %Fd%s %Fl%LF%f[change]%E",
332
        SS.MmToString(SS.gCode.feed).c_str(), &ScreenChangeGCodeParameter);
333
    Printf(false, "%Bd%Ft   plunge fd: %Fd%s %Fl%LP%f[change]%E",
334
        SS.MmToString(SS.gCode.plungeFeed).c_str(), &ScreenChangeGCodeParameter);
335

336
    Printf(false, "");
337
    Printf(false, "  %Fd%f%Ll%s  draw triangle back faces in red%E",
338
        &ScreenChangeBackFaces,
339
        SS.drawBackFaces ? CHECK_TRUE : CHECK_FALSE);
340
    Printf(false, "  %Fd%f%Ll%s  check sketch for closed contour%E",
341
        &ScreenChangeCheckClosedContour,
342
        SS.checkClosedContour ? CHECK_TRUE : CHECK_FALSE);
343
    Printf(false, "  %Fd%f%Ll%s  show areas of closed contours%E",
344
        &ScreenChangeShowContourAreas,
345
        SS.showContourAreas ? CHECK_TRUE : CHECK_FALSE);
346
    Printf(false, "  %Fd%f%Ll%s  enable automatic line constraints%E",
347
        &ScreenChangeAutomaticLineConstraints,
348
        SS.automaticLineConstraints ? CHECK_TRUE : CHECK_FALSE);
349
    Printf(false, "  %Fd%f%Ll%s  use camera mouse navigation%E", &ScreenChangeCameraNav,
350
        SS.cameraNav ? CHECK_TRUE : CHECK_FALSE);
351
    Printf(false, "  %Fd%f%Ll%s  use turntable mouse navigation%E", &ScreenChangeTurntableNav,
352
        SS.turntableNav ? CHECK_TRUE : CHECK_FALSE);
353
    Printf(false, "  %Fd%f%Ll%s  edit newly added dimensions%E",
354
        &ScreenChangeImmediatelyEditDimension,
355
        SS.immediatelyEditDimension ? CHECK_TRUE : CHECK_FALSE);
356
    Printf(false, "  %Fd%f%Ll%s  arc default is diameter%E",
357
        &ScreenChangeArcDimDefault,
358
        SS.arcDimDefaultDiameter ? CHECK_TRUE : CHECK_FALSE);
359
    Printf(false, "  %Fd%f%Ll%s  display the full path in the title bar%E",
360
           &ScreenChangeShowFullFilePath, SS.showFullFilePath ? CHECK_TRUE : CHECK_FALSE);
361
    Printf(false, "");
362
    Printf(false, "%Ft autosave interval (in minutes)%E");
363
    Printf(false, "%Ba   %d %Fl%Ll%f[change]%E",
364
        SS.autosaveInterval, &ScreenChangeAutosaveInterval);
365
    Printf(false, "");
366
    Printf(false, "%Ft redundant constraint timeout (in ms)%E");
367
    Printf(false, "%Ba   %d %Fl%Ll%f[change]%E",
368
        SS.timeoutRedundantConstr, &ScreenChangeFindConstraintTimeout);
369

370
    if(canvas) {
371
        const char *gl_vendor, *gl_renderer, *gl_version;
372
        canvas->GetIdent(&gl_vendor, &gl_renderer, &gl_version);
373
        Printf(false, "");
374
        Printf(false, " %Ftgl vendor   %E%s", gl_vendor);
375
        Printf(false, " %Ft   renderer %E%s", gl_renderer);
376
        Printf(false, " %Ft   version  %E%s", gl_version);
377
    }
378

379
    #if defined(_OPENMP)
380
        Printf(false, " %FtOpenMP enabled");
381
        Printf(false, " %Ft   threads  %E%d", omp_get_max_threads());
382
    #endif
383
}
384

385
bool TextWindow::EditControlDoneForConfiguration(const std::string &s) {
386
    switch(edit.meaning) {
387
        case Edit::LIGHT_INTENSITY:
388
            SS.lightIntensity[edit.i] = min(1.0, max(0.0, atof(s.c_str())));
389
            SS.GW.Invalidate();
390
            break;
391
        case Edit::LIGHT_AMBIENT:
392
            SS.ambientIntensity = min(1.0, max(0.0, atof(s.c_str())));
393
            SS.GW.Invalidate();
394
            break;
395
        case Edit::LIGHT_DIRECTION: {
396
            double x, y, z;
397
            if(sscanf(s.c_str(), "%lf, %lf, %lf", &x, &y, &z)==3) {
398
                SS.lightDir[edit.i] = Vector::From(x, y, z);
399
                SS.GW.Invalidate();
400
            } else {
401
                Error(_("Bad format: specify coordinates as x, y, z"));
402
            }
403
            break;
404
        }
405
        case Edit::COLOR: {
406
            Vector rgb;
407
            if(sscanf(s.c_str(), "%lf, %lf, %lf", &rgb.x, &rgb.y, &rgb.z)==3) {
408
                rgb = rgb.ClampWithin(0, 1);
409
                SS.modelColor[edit.i] = RGBf(rgb.x, rgb.y, rgb.z);
410
            } else {
411
                Error(_("Bad format: specify color as r, g, b"));
412
            }
413
            break;
414
        }
415
        case Edit::CHORD_TOLERANCE: {
416
            if(edit.i == 0) {
417
                SS.chordTol = max(0.0, atof(s.c_str()));
418
                SS.GenerateAll(SolveSpaceUI::Generate::ALL);
419
            } else {
420
                SS.exportChordTol = max(0.0, atof(s.c_str()));
421
            }
422
            break;
423
        }
424
        case Edit::MAX_SEGMENTS: {
425
            if(edit.i == 0) {
426
                SS.maxSegments = min(1000, max(7, atoi(s.c_str())));
427
                SS.GenerateAll(SolveSpaceUI::Generate::ALL);
428
            } else {
429
                SS.exportMaxSegments = min(1000, max(7, atoi(s.c_str())));
430
            }
431
            break;
432
        }
433
        case Edit::CAMERA_TANGENT: {
434
            SS.cameraTangent = (min(2.0, max(0.0, atof(s.c_str()))))/1000.0;
435
            SS.GW.Invalidate();
436
            if(!SS.usePerspectiveProj) {
437
                Message(_("The perspective factor will have no effect until you "
438
                          "enable View -> Use Perspective Projection."));
439
            }
440
            break;
441
        }
442
        case Edit::GRID_SPACING: {
443
            SS.gridSpacing = (float)min(1e4, max(1e-3, SS.StringToMm(s)));
444
            SS.GW.Invalidate();
445
            break;
446
        }
447
        case Edit::EXPLODE_DISTANCE: {
448
            SS.explodeDistance = min(1e4, max(-1e4, SS.StringToMm(s)));
449
            SS.MarkGroupDirty(SS.GW.activeGroup, true);
450
            break;
451
        }
452
        case Edit::DIGITS_AFTER_DECIMAL: {
453
            int v = atoi(s.c_str());
454
            if(v < 0 || v > 8) {
455
                Error(_("Specify between 0 and %d digits after the decimal."), 8);
456
            } else {
457
                SS.SetUnitDigitsAfterDecimal(v);
458
                SS.GW.Invalidate();
459
            }
460
            break;
461
        }
462
        case Edit::DIGITS_AFTER_DECIMAL_DEGREE: {
463
            int v = atoi(s.c_str());
464
            if(v < 0 || v > 4) {
465
                Error(_("Specify between 0 and %d digits after the decimal."), 4);
466
            } else {
467
                SS.afterDecimalDegree = v;
468
                SS.GW.Invalidate();
469
            }
470
            break;
471
        }
472
        case Edit::EXPORT_SCALE: {
473
            Expr *e = Expr::From(s, /*popUpError=*/true);
474
            if(e) {
475
                double ev = e->Eval();
476
                if(fabs(ev) < 0.001 || IsReasonable(ev)) {
477
                    Error(_("Export scale must not be zero!"));
478
                } else {
479
                    SS.exportScale = (float)ev;
480
                }
481
            }
482
            break;
483
        }
484
        case Edit::EXPORT_OFFSET: {
485
            Expr *e = Expr::From(s, /*popUpError=*/true);
486
            if(e) {
487
                double ev = SS.ExprToMm(e);
488
                if(IsReasonable(ev) || ev < 0) {
489
                    Error(_("Cutter radius offset must not be negative!"));
490
                } else {
491
                    SS.exportOffset = (float)ev;
492
                }
493
            }
494
            break;
495
        }
496
        case Edit::CANVAS_SIZE: {
497
            Expr *e = Expr::From(s, /*popUpError=*/true);
498
            if(!e) {
499
                break;
500
            }
501
            float d = (float)SS.ExprToMm(e);
502
            switch(edit.i) {
503
                case  0: SS.exportMargin.left   = d;    break;
504
                case  1: SS.exportMargin.right  = d;    break;
505
                case  2: SS.exportMargin.bottom = d;    break;
506
                case  3: SS.exportMargin.top    = d;    break;
507

508
                case 10: SS.exportCanvas.width  = d;    break;
509
                case 11: SS.exportCanvas.height = d;    break;
510
                case 12: SS.exportCanvas.dx     = d;    break;
511
                case 13: SS.exportCanvas.dy     = d;    break;
512
            }
513
            break;
514
        }
515
        case Edit::G_CODE_DEPTH: {
516
            Expr *e = Expr::From(s, /*popUpError=*/true);
517
            if(e) SS.gCode.depth = (float)SS.ExprToMm(e);
518
            break;
519
        }
520
        case Edit::G_CODE_SAFE_HEIGHT: {
521
            Expr *e = Expr::From(s, /*popUpError=*/true);
522
            if(e) SS.gCode.safeHeight = (float)SS.ExprToMm(e);
523
            break;
524
        }
525
        case Edit::G_CODE_PASSES: {
526
            Expr *e = Expr::From(s, /*popUpError=*/true);
527
            if(e) SS.gCode.passes = (int)(e->Eval());
528
            SS.gCode.passes = max(1, min(1000, SS.gCode.passes));
529
            break;
530
        }
531
        case Edit::G_CODE_FEED: {
532
            Expr *e = Expr::From(s, /*popUpError=*/true);
533
            if(e) SS.gCode.feed = (float)SS.ExprToMm(e);
534
            break;
535
        }
536
        case Edit::G_CODE_PLUNGE_FEED: {
537
            Expr *e = Expr::From(s, /*popUpError=*/true);
538
            if(e) SS.gCode.plungeFeed = (float)SS.ExprToMm(e);
539
            break;
540
        }
541
        case Edit::AUTOSAVE_INTERVAL: {
542
            int interval = atoi(s.c_str());
543
            if(interval) {
544
                if(interval >= 1) {
545
                    SS.autosaveInterval = interval;
546
                    SS.ScheduleAutosave();
547
                } else {
548
                    Error(_("Bad value: autosave interval should be positive"));
549
                }
550
            } else {
551
                Error(_("Bad format: specify interval in integral minutes"));
552
            }
553
            break;
554
        }
555
        case Edit::FIND_CONSTRAINT_TIMEOUT: {
556
            int timeout = atoi(s.c_str());
557
            if(timeout) {
558
                if(timeout >= 1) {
559
                    SS.timeoutRedundantConstr = timeout;
560
                } else {
561
                    SS.timeoutRedundantConstr = 1000;
562
                }
563
            }
564
            break;
565
        }
566

567
        default: return false;
568
    }
569
    return true;
570
}
571

572