1 #include "LDPreferences.h"
2 #include "LDUserDefaultsKeys.h"
3 #include <TCFoundation/TCAlertManager.h>
4 #include <TCFoundation/TCMacros.h>
5 #include <TCFoundation/TCUserDefaults.h>
6 #include <TCFoundation/TCWebClient.h>
7 #include <LDLoader/LDLPalette.h>
8 #include <LDLoader/LDLModel.h>
9
10 #ifdef WIN32
11 #if defined(_MSC_VER) && _MSC_VER >= 1400 && defined(_DEBUG)
12 #define new DEBUG_CLIENTBLOCK
13 #endif // _DEBUG
14 #endif // WIN32
15
16 std::string LDPreferences::m_emptyString;
17 std::string LDPreferences::m_modelDir;
18
LDPreferences(LDrawModelViewer * modelViewer)19 LDPreferences::LDPreferences(LDrawModelViewer* modelViewer)
20 :m_modelViewer(modelViewer ? ((LDrawModelViewer*)modelViewer->retain()) :
21 NULL)
22 {
23 int i;
24 SaveOpStringMap::const_iterator it;
25
26 m_globalSettings[ZOOM_MAX_KEY] = true;
27 m_globalSettings[SHOW_ERRORS_KEY] = true;
28 m_globalSettings[PROXY_TYPE_KEY] = true;
29 m_globalSettings[PROXY_SERVER_KEY] = true;
30 m_globalSettings[PROXY_PORT_KEY] = true;
31 m_globalSettings[CHECK_PART_TRACKER_KEY] = true;
32 m_globalSettings[CHECK_PART_WAIT_KEY] = true;
33 m_globalSettings[CHECK_PART_UPDATE_WAIT_KEY] = true;
34 m_globalSettings[CAMERA_GLOBE_KEY] = true;
35 m_globalSettings[INV_SHOW_MODEL_KEY] = true;
36 m_globalSettings[INV_EXTERNAL_CSS_KEY] = true;
37 m_globalSettings[INV_PART_IMAGES_KEY] = true;
38 m_globalSettings[INV_SHOW_FILE_KEY] = true;
39 m_globalSettings[INV_SHOW_TOTAL_KEY] = true;
40 m_globalSettings[INV_COLUMN_ORDER_KEY] = true;
41 m_globalSettings[INV_LAST_SAVE_PATH_KEY] = true;
42 m_globalSettings[MULTI_THREADED_KEY] = true;
43 m_globalSettings[LDRAWDIR_KEY] = true;
44 m_globalSettings[EXTRA_SEARCH_DIRS_KEY] = true;
45 m_globalSettings[STRIPS_KEY] = true;
46 m_defaultColorNumber = -1;
47 for (i = 0; i < 16; i++)
48 {
49 char key[128];
50
51 sprintf(key, "%s/Color%02d", CUSTOM_COLORS_KEY, i);
52 m_globalSettings[key] = true;
53 }
54 if (m_modelViewer != NULL)
55 {
56 m_modelViewer->setPreferences(this);
57 }
58 setupSaveDir(SOSnapshot, SNAPSHOTS_DIR_MODE_KEY, SNAPSHOTS_DIR_KEY,
59 LAST_SNAPSHOT_DIR_KEY);
60 setupSaveDir(SOPartsList, PARTS_LISTS_DIR_MODE_KEY, PARTS_LISTS_DIR_KEY,
61 INV_LAST_SAVE_PATH_KEY);
62 setupSaveDir(SOExport, EXPORTS_DIR_MODE_KEY, EXPORTS_DIR_KEY,
63 LAST_EXPORT_DIR_KEY);
64 }
65
~LDPreferences(void)66 LDPreferences::~LDPreferences(void)
67 {
68 }
69
dealloc(void)70 void LDPreferences::dealloc(void)
71 {
72 TCObject::release(m_modelViewer);
73 TCObject::dealloc();
74 }
75
setupSaveDir(SaveOp op,const std::string & dirModeKey,const std::string & dirKey,const std::string & lastDirKey)76 void LDPreferences::setupSaveDir(
77 SaveOp op,
78 const std::string &dirModeKey,
79 const std::string &dirKey,
80 const std::string &lastDirKey)
81 {
82 m_saveDirModeKeys[op] = dirModeKey;
83 m_saveDirKeys[op] = dirKey;
84 m_lastSaveDirKeys[op] = lastDirKey;
85 m_globalSettings[dirModeKey] = true;
86 m_globalSettings[dirKey] = true;
87 m_globalSettings[lastDirKey] = true;
88 }
89
setModelViewer(LDrawModelViewer * value)90 void LDPreferences::setModelViewer(LDrawModelViewer *value)
91 {
92 if (value != m_modelViewer)
93 {
94 //if (m_modelViewer != NULL)
95 //{
96 // m_modelViewer->setPreferences(NULL);
97 //}
98 TCObject::release(m_modelViewer);
99 m_modelViewer = value;
100 if (m_modelViewer != NULL)
101 {
102 m_modelViewer->retain();
103 m_modelViewer->setPreferences(this);
104 }
105 }
106 }
107
getColor(int r,int g,int b)108 int LDPreferences::getColor(int r, int g, int b)
109 {
110 return ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF);
111 }
112
getRGB(int color,int & r,int & g,int & b)113 void LDPreferences::getRGB(int color, int &r, int &g, int &b)
114 {
115 // Colors are stored in RGB format.
116 r = (color >> 16) & 0xFF;
117 g = (color >> 8) & 0xFF;
118 b = color & 0xFF;
119 }
120
getColorSetting(const char * key,int & r,int & g,int & b,TCULong defaultColor)121 void LDPreferences::getColorSetting(const char *key, int &r, int &g, int &b,
122 TCULong defaultColor)
123 {
124 int value = (int)getLongSetting(key, defaultColor);
125
126 getRGB(value, r, g, b);
127 }
128
applySettings(void)129 void LDPreferences::applySettings(void)
130 {
131 applyGeneralSettings();
132 applyLDrawSettings();
133 applyGeometrySettings();
134 applyEffectsSettings();
135 applyPrimitivesSettings();
136 applyUpdatesSettings();
137 if (m_modelViewer != NULL)
138 {
139 m_modelViewer->setZoomMax(m_zoomMax);
140 m_modelViewer->setDistanceMultiplier(1.0f / m_defaultZoom);
141 m_modelViewer->setLDConfig(m_ldConfig);
142 }
143 setupDefaultRotationMatrix();
144 setupModelCenter();
145 setupModelSize();
146 }
147
applyGeneralSettings(void)148 void LDPreferences::applyGeneralSettings(void)
149 {
150 if (m_modelViewer != NULL)
151 {
152 int r, g, b;
153
154 // FSAA taken care of automatically.
155 getRGB(m_backgroundColor, r, g, b);
156 m_modelViewer->setBackgroundRGBA(r, g, b, 0);
157 getRGB(m_defaultColor, r, g, b);
158 m_modelViewer->setProcessLDConfig(m_processLdConfig);
159 m_modelViewer->setRandomColors(m_randomColors);
160 m_modelViewer->setSkipValidation(m_skipValidation);
161 // showFrameRate taken care of automatically.
162 m_modelViewer->setShowAxes(m_showAxes);
163 m_modelViewer->setMultiThreaded(m_multiThreaded);
164 // showErrors taken care of automatically.
165 // fullScreenRefresh taken care of automatically.
166 m_modelViewer->setFov(m_fov);
167 m_modelViewer->setDefaultRGB((TCByte)r, (TCByte)g, (TCByte)b,
168 m_transDefaultColor);
169 m_modelViewer->setDefaultColorNumber(m_defaultColorNumber);
170 m_modelViewer->setLineSmoothing(m_lineSmoothing);
171 m_modelViewer->setMemoryUsage(m_memoryUsage);
172 }
173 }
174
applyLDrawSettings(void)175 void LDPreferences::applyLDrawSettings(void)
176 {
177 if (m_ldrawDir.size() > 0)
178 {
179 if (strcmp(m_ldrawDir.c_str(), LDLModel::lDrawDir()) != 0)
180 {
181 LDLModel::setLDrawDir(m_ldrawDir.c_str());
182 if (m_modelViewer != NULL)
183 {
184 m_modelViewer->setNeedsReload();
185 }
186 }
187 }
188 if (m_modelViewer != NULL)
189 {
190 TCStringArray *oldExtraDirs = m_modelViewer->getExtraSearchDirs();
191 TCStringArray *extraDirs = new TCStringArray;
192 bool different = false;
193 unsigned int oldCount = 0;
194 size_t newCount = m_extraDirs.size();
195
196 if (oldExtraDirs)
197 {
198 oldCount = oldExtraDirs->getCount();
199 }
200 if (oldCount != newCount)
201 {
202 different = true;
203 }
204 for (int i = 0; i < (int)newCount; i++)
205 {
206 const char *extraDir = m_extraDirs[i].c_str();
207
208 extraDirs->addString(extraDir);
209 if (!different && strcmp(extraDir, oldExtraDirs->stringAtIndex(i)))
210 {
211 different = true;
212 }
213 }
214 if (different)
215 {
216 m_modelViewer->setExtraSearchDirs(extraDirs);
217 }
218 extraDirs->release();
219 }
220 }
221
applyGeometrySettings(void)222 void LDPreferences::applyGeometrySettings(void)
223 {
224 if (m_modelViewer != NULL)
225 {
226 if (m_useSeams)
227 {
228 m_modelViewer->setSeamWidth(m_seamWidth / 100.0f);
229 }
230 else
231 {
232 m_modelViewer->setSeamWidth(0.0f);
233 }
234 m_modelViewer->setBoundingBoxesOnly(m_boundingBoxesOnly);
235 m_modelViewer->setDrawWireframe(m_drawWireframe);
236 m_modelViewer->setUseWireframeFog(m_useWireframeFog);
237 m_modelViewer->setRemoveHiddenLines(m_removeHiddenLines);
238 m_modelViewer->setWireframeLineWidth((GLfloat)m_wireframeThickness);
239 m_modelViewer->setBfc(m_bfc);
240 m_modelViewer->setRedBackFaces(m_redBackFaces);
241 m_modelViewer->setGreenFrontFaces(m_greenFrontFaces);
242 m_modelViewer->setBlueNeutralFaces(m_blueNeutralFaces);
243 m_modelViewer->setShowsHighlightLines(m_showHighlightLines);
244 m_modelViewer->setEdgesOnly(m_edgesOnly);
245 m_modelViewer->setDrawConditionalHighlights(m_drawConditionalHighlights);
246 m_modelViewer->setShowAllConditionalLines(m_showAllConditionalLines);
247 m_modelViewer->setShowConditionalControlPoints(
248 m_showConditionalControlPoints);
249 m_modelViewer->setUsePolygonOffset(m_usePolygonOffset);
250 m_modelViewer->setBlackHighlights(m_blackHighlights);
251 m_modelViewer->setHighlightLineWidth((GLfloat)m_edgeThickness);
252 }
253 }
254
applyEffectsSettings(void)255 void LDPreferences::applyEffectsSettings(void)
256 {
257 if (m_modelViewer != NULL)
258 {
259 m_modelViewer->setUseLighting(m_useLighting);
260 m_modelViewer->setQualityLighting(m_qualityLighting);
261 m_modelViewer->setSubduedLighting(m_subduedLighting);
262 m_modelViewer->setUsesSpecular(m_useSpecular);
263 m_modelViewer->setOneLight(m_oneLight);
264 m_modelViewer->setLightVector(m_lightVector);
265 m_modelViewer->setDrawLightDats(m_drawLightDats);
266 m_modelViewer->setOptionalStandardLight(m_optionalStandardLight);
267 m_modelViewer->setNoLightGeom(m_noLightGeom);
268 m_modelViewer->setStereoMode(m_stereoMode);
269 m_modelViewer->setStereoEyeSpacing((GLfloat)m_stereoEyeSpacing);
270 m_modelViewer->setCutawayMode(m_cutawayMode);
271 m_modelViewer->setCutawayAlpha((TCFloat32)m_cutawayAlpha / 100.0f);
272 m_modelViewer->setCutawayLineWidth((TCFloat32)m_cutawayThickness);
273 m_modelViewer->setSortTransparent(m_sortTransparent);
274 m_modelViewer->setUseStipple(m_useStipple);
275 m_modelViewer->setUsesFlatShading(m_useFlatShading);
276 m_modelViewer->setObi(m_obi);
277 m_modelViewer->setPerformSmoothing(m_performSmoothing);
278 }
279 }
280
applyPrimitivesSettings(void)281 void LDPreferences::applyPrimitivesSettings(void)
282 {
283 if (m_modelViewer != NULL)
284 {
285 m_modelViewer->setAllowPrimitiveSubstitution(m_allowPrimitiveSubstitution);
286 m_modelViewer->setTextureStuds(m_textureStuds);
287 m_modelViewer->setTextureFilterType(m_textureFilterType);
288 m_modelViewer->setAnisoLevel((TCFloat32)m_anisoLevel);
289 m_modelViewer->setAnisoLevel(m_anisoLevel);
290 m_modelViewer->setCurveQuality(m_curveQuality);
291 m_modelViewer->setQualityStuds(m_qualityStuds);
292 m_modelViewer->setHiResPrimitives(m_hiResPrimitives);
293 m_modelViewer->setTexmaps(m_texmaps);
294 m_modelViewer->setTexturesAfterTransparent(true);
295 m_modelViewer->setTextureOffsetFactor(m_textureOffsetFactor);
296 m_modelViewer->setUseStrips(m_useStrips);
297 }
298 }
299
applyUpdatesSettings(void)300 void LDPreferences::applyUpdatesSettings(void)
301 {
302 if (m_modelViewer != NULL)
303 {
304 m_modelViewer->setCheckPartTracker(m_checkPartTracker);
305 m_modelViewer->setMissingPartWait(m_missingPartWait);
306 m_modelViewer->setUpdatedPartWait(m_updatedPartWait);
307 if (m_proxyType == 2)
308 {
309 TCWebClient::setProxyServer(m_proxyServer.c_str());
310 TCWebClient::setProxyPort(m_proxyPort);
311 }
312 #ifdef WIN32
313 else if (m_proxyType == 1)
314 {
315 std::string appName = TCUserDefaults::getAppName();
316
317 // This is sort of cheating, but since I know exactly how TCUserDefaults
318 // works, I know that this will get the job done. Note that if the
319 // actual type of the data in the registry doesn't match the requested
320 // type, TCUserDefaults treats the registry value as if it doesn't
321 // exist.
322 TCUserDefaults::setAppName(
323 "Microsoft/Windows/CurrentVersion/Internet Settings");
324 if (TCUserDefaults::longForKey("ProxyEnable", 0, false))
325 {
326 char *proxyServer = TCUserDefaults::stringForKey("ProxyServer",
327 NULL, false);
328
329 if (proxyServer)
330 {
331 char *colon = (char *)strchr(proxyServer, ':');
332
333 if (colon)
334 {
335 int proxyPort;
336
337 *colon = 0;
338 if (sscanf(&colon[1], "%d", &proxyPort) == 1)
339 {
340 TCWebClient::setProxyServer(proxyServer);
341 TCWebClient::setProxyPort(proxyPort);
342 }
343 }
344 delete[] proxyServer;
345 }
346 }
347 TCUserDefaults::setAppName(appName.c_str());
348 }
349 #endif
350 else
351 {
352 TCWebClient::setProxyServer(NULL);
353 }
354 }
355 }
356
loadSettings(void)357 void LDPreferences::loadSettings(void)
358 {
359 loadGeneralSettings();
360 loadLDrawSettings();
361 loadGeometrySettings();
362 loadEffectsSettings();
363 loadPrimitivesSettings();
364 loadUpdatesSettings();
365 loadInventorySettings();
366 m_changedSettings.clear();
367
368 m_skipValidation = false;
369 m_zoomMax = getLongSetting(ZOOM_MAX_KEY, 199) / 100.0f;
370 m_defaultZoom = getFloatSetting(DEFAULT_ZOOM_KEY, 1.0f);
371 m_ldConfig = getStringSetting(LDCONFIG_KEY);
372 }
373
loadDefaultGeneralSettings(bool initializing)374 void LDPreferences::loadDefaultGeneralSettings(bool initializing /*= true*/)
375 {
376 int i;
377
378 if (initializing)
379 {
380 m_initializing = true;
381 }
382 setFsaaMode(0);
383 setLineSmoothing(false);
384 setBackgroundColor(0, 0, 0);
385 setDefaultColor(0x99, 0x99, 0x99);
386 setTransDefaultColor(false);
387 setProcessLdConfig(true);
388 setRandomColors(false);
389 setShowFps(false);
390 setShowAxes(false);
391 setShowErrors(true);
392 setDisableSmp(false);
393 setFullScreenRefresh(0);
394 setFov(45.0f);
395 setMemoryUsage(2);
396 for (i = 0; i < 16; i++)
397 {
398 int r, g, b, a;
399
400 LDLPalette::getDefaultRGBA(i, r, g, b, a);
401 setCustomColor(i, r, g, b);
402 }
403 setSaveDirDefault(SOSnapshot, DDMModelDir);
404 setSaveDirDefault(SOPartsList, DDMLastDir);
405 setSaveDirDefault(SOExport, DDMModelDir);
406 m_initializing = false;
407 }
408
loadDefaultLDrawSettings(bool initializing)409 void LDPreferences::loadDefaultLDrawSettings(bool initializing /*= true*/)
410 {
411 if (initializing)
412 {
413 m_initializing = true;
414 }
415 setLDrawDir(LDLModel::lDrawDir(true));
416 setExtraDirs(StringVector());
417 m_initializing = false;
418 }
419
loadDefaultGeometrySettings(bool initializing)420 void LDPreferences::loadDefaultGeometrySettings(bool initializing /*= true*/)
421 {
422 if (initializing)
423 {
424 m_initializing = true;
425 }
426 setUseSeams(true);
427 setSeamWidth(50);
428 setBoundingBoxesOnly(false);
429 setDrawWireframe(false);
430 setUseWireframeFog(false);
431 setRemoveHiddenLines(false);
432 setWireframeThickness(1);
433 setBfc(true);
434 setRedBackFaces(false);
435 setGreenFrontFaces(false);
436 setBlueNeutralFaces(false);
437 setShowHighlightLines(false);
438 setEdgesOnly(false);
439 setDrawConditionalHighlights(true);
440 setShowAllConditionalLines(false);
441 setShowConditionalControlPoints(false);
442 setUsePolygonOffset(true);
443 setBlackHighlights(false);
444 setEdgeThickness(1);
445 m_initializing = false;
446 }
447
loadDefaultEffectsSettings(bool initializing)448 void LDPreferences::loadDefaultEffectsSettings(bool initializing /*= true*/)
449 {
450 if (initializing)
451 {
452 m_initializing = true;
453 }
454 setUseLighting(true);
455 setQualityLighting(false);
456 setSubduedLighting(false);
457 setUseSpecular(true);
458 setOneLight(false);
459 setLightVector(TCVector(0.0, 0.0, 1.0));
460 setDrawLightDats(true);
461 setOptionalStandardLight(true);
462 setNoLightGeom(false);
463 setStereoMode(LDVStereoNone);
464 setStereoEyeSpacing(50);
465 setCutawayMode(LDVCutawayNormal);
466 setCutawayAlpha(100);
467 setCutawayThickness(1);
468 setSortTransparent(true);
469 setUseStipple(false);
470 setUseFlatShading(false);
471 setObi(false);
472 setPerformSmoothing(true);
473 m_initializing = false;
474 }
475
loadDefaultPrimitivesSettings(bool initializing)476 void LDPreferences::loadDefaultPrimitivesSettings(bool initializing /*= true*/)
477 {
478 if (initializing)
479 {
480 m_initializing = true;
481 }
482 setAllowPrimitiveSubstitution(true);
483 setTextureStuds(true);
484 setTextureFilterType(GL_LINEAR_MIPMAP_LINEAR);
485 setAnisoLevel(1.0f);
486 setCurveQuality(2);
487 setQualityStuds(false);
488 setHiResPrimitives(false);
489 setTexmaps(true);
490 setTextureOffsetFactor(5.0);
491 setUseStrips(true);
492 m_initializing = false;
493 }
494
loadDefaultUpdatesSettings(bool initializing)495 void LDPreferences::loadDefaultUpdatesSettings(bool initializing /*= true*/)
496 {
497 if (initializing)
498 {
499 m_initializing = true;
500 }
501 setProxyType(0);
502 setProxyServer("");
503 setProxyPort(80);
504 setCheckPartTracker(true);
505 setMissingPartWait(7);
506 setUpdatedPartWait(7);
507 m_initializing = false;
508 }
509
loadDefaultInventorySettings(bool initializing)510 void LDPreferences::loadDefaultInventorySettings(bool initializing /*= true*/)
511 {
512 if (initializing)
513 {
514 m_initializing = true;
515 }
516 setInvShowModel(false);
517 setInvOverwriteSnapshot(false);
518 setInvExternalCss(false);
519 setInvPartImages(true);
520 setInvShowFile(true);
521 setInvShowTotal(true);
522 LongVector columnOrder;
523 columnOrder.push_back(1); // Part
524 columnOrder.push_back(3); // Color
525 columnOrder.push_back(4); // Quantity
526 setInvColumnOrder(columnOrder);
527 setSaveDirDefault(SOPartsList, DDMLastDir);
528 m_initializing = false;
529 }
530
loadGeneralSettings(void)531 void LDPreferences::loadGeneralSettings(void)
532 {
533 int i;
534
535 loadDefaultGeneralSettings();
536 m_fsaaMode = getIntSetting(FSAA_MODE_KEY, m_fsaaMode);
537 m_lineSmoothing = getBoolSetting(LINE_SMOOTHING_KEY, m_lineSmoothing);
538 m_backgroundColor = (TCULong)getLongSetting(BACKGROUND_COLOR_KEY,
539 m_backgroundColor);
540 m_defaultColor = (TCULong)getLongSetting(DEFAULT_COLOR_KEY, m_defaultColor);
541 m_transDefaultColor = getBoolSetting(TRANS_DEFAULT_COLOR_KEY,
542 m_transDefaultColor);
543 m_defaultColorNumber = getIntSetting(DEFAULT_COLOR_NUMBER_KEY,
544 m_defaultColorNumber);
545 m_processLdConfig = getBoolSetting(PROCESS_LDCONFIG_KEY, m_processLdConfig);
546 m_randomColors = getBoolSetting(RANDOM_COLORS_KEY, m_randomColors);
547 m_skipValidation = getBoolSetting(SKIP_VALIDATION_KEY, m_skipValidation);
548 m_showFps = getBoolSetting(SHOW_FPS_KEY, m_showFps);
549 m_showAxes = getBoolSetting(SHOW_AXES_KEY, m_showAxes);
550 m_showErrors = getBoolSetting(SHOW_ERRORS_KEY, m_showErrors);
551 m_multiThreaded = getBoolSetting(MULTI_THREADED_KEY, m_multiThreaded);
552 m_fullScreenRefresh = getIntSetting(FULLSCREEN_REFRESH_KEY,
553 m_fullScreenRefresh);
554 m_fov = getFloatSetting(FOV_KEY, (TCFloat32)m_fov);
555 m_memoryUsage = getIntSetting(MEMORY_USAGE_KEY, m_memoryUsage);
556 if (m_memoryUsage < 0 || m_memoryUsage > 2)
557 {
558 setMemoryUsage(2, true);
559 }
560 for (i = 0; i < 16; i++)
561 {
562 char key[128];
563
564 sprintf(key, "%s/Color%02d", CUSTOM_COLORS_KEY, i);
565 // Windows XP doesn't like the upper bits to be set, so mask those out.
566 m_customColors[i] = getLongSetting(key, m_customColors[i]) & 0xFFFFFF;
567 }
568 loadSaveDir(SOSnapshot);
569 loadSaveDir(SOPartsList);
570 loadSaveDir(SOExport);
571 //m_snapshotsDirMode = (DefaultDirMode)getIntSetting(SNAPSHOTS_DIR_MODE_KEY,
572 // m_snapshotsDirMode);
573 //m_snapshotsDir = getStringSetting(SNAPSHOTS_DIR_KEY, m_snapshotsDir.c_str(),
574 // true);
575 //m_partsListsDirMode = (DefaultDirMode)getIntSetting(
576 // PARTS_LISTS_DIR_MODE_KEY, m_partsListsDirMode);
577 //m_partsListsDir = getStringSetting(PARTS_LISTS_DIR_KEY,
578 // m_partsListsDir.c_str(), true);
579 }
580
loadLDrawSettings(void)581 void LDPreferences::loadLDrawSettings(void)
582 {
583 std::string dirKey = std::string(EXTRA_SEARCH_DIRS_KEY) + "/Dir";
584
585 loadDefaultLDrawSettings();
586 m_ldrawDir = getStringSetting(LDRAWDIR_KEY, m_ldrawDir.c_str(), true);
587 m_extraDirs = getStringVectorSetting(dirKey.c_str(), m_extraDirs,
588 true, 3, 1);
589 }
590
loadGeometrySettings(void)591 void LDPreferences::loadGeometrySettings(void)
592 {
593 int useSeams;
594
595 loadDefaultGeometrySettings();
596 useSeams = getIntSetting(SEAMS_KEY, -1);
597 m_seamWidth = getIntSetting(SEAM_WIDTH_KEY, m_seamWidth);
598 if (useSeams == -1)
599 {
600 if (m_seamWidth)
601 {
602 m_useSeams = true;
603 }
604 else
605 {
606 m_useSeams = false;
607 }
608 }
609 else
610 {
611 m_useSeams = useSeams != 0;
612 }
613 m_boundingBoxesOnly = getBoolSetting(BOUNDING_BOXES_ONLY_KEY,
614 m_boundingBoxesOnly);
615 m_drawWireframe = getBoolSetting(WIREFRAME_KEY, m_drawWireframe);
616 m_useWireframeFog = getBoolSetting(WIREFRAME_FOG_KEY, m_useWireframeFog);
617 m_removeHiddenLines = getBoolSetting(REMOVE_HIDDEN_LINES_KEY,
618 m_removeHiddenLines);
619 m_wireframeThickness = getIntSetting(WIREFRAME_THICKNESS_KEY,
620 m_wireframeThickness);
621 m_bfc = getBoolSetting(BFC_KEY, m_bfc);
622 m_redBackFaces = getBoolSetting(RED_BACK_FACES_KEY, m_redBackFaces);
623 m_greenFrontFaces = getBoolSetting(GREEN_FRONT_FACES_KEY,
624 m_greenFrontFaces);
625 m_blueNeutralFaces = getBoolSetting(BLUE_NEUTRAL_FACES_KEY,
626 m_blueNeutralFaces);
627 m_showHighlightLines = getBoolSetting(SHOW_HIGHLIGHT_LINES_KEY,
628 m_showHighlightLines);
629 m_edgesOnly = getBoolSetting(EDGES_ONLY_KEY, m_edgesOnly);
630 m_drawConditionalHighlights = getBoolSetting(CONDITIONAL_HIGHLIGHTS_KEY,
631 m_drawConditionalHighlights);
632 m_showAllConditionalLines = getBoolSetting(SHOW_ALL_TYPE5_KEY,
633 m_showAllConditionalLines);
634 m_showConditionalControlPoints =
635 getBoolSetting(SHOW_TYPE5_CONTROL_POINTS_KEY,
636 m_showConditionalControlPoints);
637 m_usePolygonOffset = getBoolSetting(POLYGON_OFFSET_KEY, m_usePolygonOffset);
638 m_blackHighlights = getBoolSetting(BLACK_HIGHLIGHTS_KEY, m_blackHighlights);
639 m_edgeThickness = getIntSetting(EDGE_THICKNESS_KEY, m_edgeThickness);
640 }
641
loadEffectsSettings(void)642 void LDPreferences::loadEffectsSettings(void)
643 {
644 loadDefaultEffectsSettings();
645 m_useLighting = getBoolSetting(LIGHTING_KEY, m_useLighting);
646 m_qualityLighting = getBoolSetting(QUALITY_LIGHTING_KEY, m_qualityLighting);
647 m_subduedLighting = getBoolSetting(SUBDUED_LIGHTING_KEY, m_subduedLighting);
648 m_useSpecular = getBoolSetting(SPECULAR_KEY, m_useSpecular);
649 m_oneLight = getBoolSetting(ONE_LIGHT_KEY, m_oneLight);
650 m_lightVector = getTCVectorSetting(LIGHT_VECTOR_KEY, m_lightVector);
651 m_drawLightDats = getBoolSetting(DRAW_LIGHT_DATS_KEY, m_drawLightDats);
652 m_optionalStandardLight = getBoolSetting(OPTIONAL_STANDARD_LIGHT_KEY,
653 m_optionalStandardLight);
654 m_noLightGeom = getBoolSetting(NO_LIGHT_GEOM_KEY, m_noLightGeom);
655 m_stereoMode = (LDVStereoMode)getLongSetting(STEREO_MODE_KEY, m_stereoMode);
656 m_stereoEyeSpacing = getIntSetting(STEREO_SPACING_KEY, m_stereoEyeSpacing);
657 m_cutawayMode = (LDVCutawayMode)getLongSetting(CUTAWAY_MODE_KEY,
658 m_cutawayMode);
659 m_cutawayAlpha = getIntSetting(CUTAWAY_ALPHA_KEY, m_cutawayAlpha);
660 m_cutawayThickness = getIntSetting(CUTAWAY_THICKNESS_KEY,
661 m_cutawayThickness);
662 m_sortTransparent = getBoolSetting(SORT_KEY, m_sortTransparent);
663 m_useStipple = getBoolSetting(STIPPLE_KEY, m_useStipple);
664 m_useFlatShading = getBoolSetting(FLAT_SHADING_KEY, m_useFlatShading);
665 m_obi = getBoolSetting(OBI_KEY, m_obi);
666 m_performSmoothing = getBoolSetting(PERFORM_SMOOTHING_KEY,
667 m_performSmoothing);
668 }
669
loadPrimitivesSettings(void)670 void LDPreferences::loadPrimitivesSettings(void)
671 {
672 loadDefaultPrimitivesSettings();
673 m_allowPrimitiveSubstitution =
674 getBoolSetting(PRIMITIVE_SUBSTITUTION_KEY,
675 m_allowPrimitiveSubstitution);
676 m_textureStuds = getBoolSetting(TEXTURE_STUDS_KEY, m_textureStuds);
677 m_textureFilterType = getIntSetting(TEXTURE_FILTER_TYPE_KEY,
678 m_textureFilterType);
679 m_anisoLevel = getFloatSetting(ANISO_LEVEL_KEY, m_anisoLevel);
680 m_curveQuality = getIntSetting(CURVE_QUALITY_KEY, m_curveQuality);
681 m_qualityStuds = getBoolSetting(QUALITY_STUDS_KEY, m_qualityStuds);
682 m_hiResPrimitives = getBoolSetting(HI_RES_PRIMITIVES_KEY,
683 m_hiResPrimitives);
684 m_texmaps = getBoolSetting(TEXMAPS_KEY, m_texmaps);
685 m_textureOffsetFactor = getFloatSetting(TEXTURE_OFFSET_FACTOR_KEY,
686 m_textureOffsetFactor);
687 m_useStrips = getBoolSetting(STRIPS_KEY, m_useStrips);
688 }
689
loadUpdatesSettings(void)690 void LDPreferences::loadUpdatesSettings(void)
691 {
692 loadDefaultUpdatesSettings();
693 m_proxyType = getIntSetting(PROXY_TYPE_KEY, m_proxyType);
694 m_proxyServer = getStringSetting(PROXY_SERVER_KEY, NULL);
695 m_proxyPort = getIntSetting(PROXY_PORT_KEY, m_proxyPort);
696 m_checkPartTracker = getBoolSetting(CHECK_PART_TRACKER_KEY,
697 m_checkPartTracker);
698 m_missingPartWait = getIntSetting(CHECK_PART_WAIT_KEY, m_missingPartWait);
699 m_updatedPartWait = getIntSetting(CHECK_PART_UPDATE_WAIT_KEY,
700 m_updatedPartWait);
701 }
702
loadInventorySettings(void)703 void LDPreferences::loadInventorySettings(void)
704 {
705 loadDefaultInventorySettings();
706 m_invShowModel = getBoolSetting(INV_SHOW_MODEL_KEY, m_invShowModel);
707 m_invOverwriteSnapshot = getBoolSetting(INV_OVERWRITE_SNAPSHOT_KEY,
708 m_invOverwriteSnapshot);
709 m_invExternalCss = getBoolSetting(INV_EXTERNAL_CSS_KEY, m_invExternalCss);
710 m_invPartImages = getBoolSetting(INV_PART_IMAGES_KEY, m_invPartImages);
711 m_invShowFile = getBoolSetting(INV_SHOW_FILE_KEY, m_invShowFile);
712 m_invShowTotal = getBoolSetting(INV_SHOW_TOTAL_KEY, m_invShowTotal);
713 m_invColumnOrder = getLongVectorSetting(INV_COLUMN_ORDER_KEY,
714 m_invColumnOrder);
715 loadSaveDir(SOPartsList);
716 //m_invLastSavePath = getStringSetting(INV_LAST_SAVE_PATH_KEY,
717 // m_invLastSavePath.c_str(), true);
718 }
719
commitSettings(void)720 void LDPreferences::commitSettings(void)
721 {
722 commitGeneralSettings(false);
723 commitLDrawSettings(false);
724 commitGeometrySettings(false);
725 commitEffectsSettings(false);
726 commitPrimitivesSettings(false);
727 commitUpdatesSettings(false);
728 commitInventorySettings(false);
729 TCUserDefaults::flush();
730 //commitPrefSetsSettings();
731 }
732
commitGeneralSettings(bool flush)733 void LDPreferences::commitGeneralSettings(bool flush /*= true*/)
734 {
735 int i;
736 int r, g, b;
737
738 setFsaaMode(m_fsaaMode, true);
739 setLineSmoothing(m_lineSmoothing, true);
740 getRGB(m_backgroundColor, r, g, b);
741 setBackgroundColor(r, g, b, true);
742 getRGB(m_defaultColor, r, g, b);
743 setDefaultColor(r, g, b, true);
744 setTransDefaultColor(m_transDefaultColor, true);
745 for (i = 0; i < 16; i++)
746 {
747 getRGB(m_customColors[i], r, g, b);
748 setCustomColor(i, r, g, b, true);
749 }
750 setProcessLdConfig(m_processLdConfig, true);
751 setRandomColors(m_randomColors, true);
752 setShowFps(m_showFps, true);
753 setShowAxes(m_showAxes, true);
754 setShowErrors(m_showErrors, true);
755 setDisableSmp(!m_multiThreaded, true);
756 setFullScreenRefresh(m_fullScreenRefresh, true);
757 setFov(m_fov, true);
758 setMemoryUsage(m_memoryUsage, true);
759 commitSaveDir(SOSnapshot);
760 commitSaveDir(SOPartsList);
761 commitSaveDir(SOExport);
762 //setSnapshotsDirMode(m_snapshotsDirMode, true);
763 //setSnapshotsDir(m_snapshotsDir.c_str(), true);
764 //setPartsListsDirMode(m_partsListsDirMode, true);
765 //setPartsListsDir(m_partsListsDir.c_str(), true);
766 if (flush)
767 {
768 TCUserDefaults::flush();
769 }
770 }
771
commitLDrawSettings(bool flush)772 void LDPreferences::commitLDrawSettings(bool flush /*= true*/)
773 {
774 setLDrawDir(m_ldrawDir.c_str(), true);
775 setExtraDirs(m_extraDirs, true);
776 if (flush)
777 {
778 TCUserDefaults::flush();
779 }
780 }
781
commitGeometrySettings(bool flush)782 void LDPreferences::commitGeometrySettings(bool flush /*= true*/)
783 {
784 setSetting(m_useSeams, m_useSeams, SEAMS_KEY, true);
785 if (getUseSeams())
786 {
787 setSeamWidth(m_seamWidth, true);
788 }
789 setBoundingBoxesOnly(m_boundingBoxesOnly, true);
790 setDrawWireframe(m_drawWireframe, true);
791 setUseWireframeFog(m_useWireframeFog, true);
792 setRemoveHiddenLines(m_removeHiddenLines, true);
793 setWireframeThickness(m_wireframeThickness, true);
794 setBfc(m_bfc, true);
795 setRedBackFaces(m_redBackFaces, true);
796 setGreenFrontFaces(m_greenFrontFaces, true);
797 setBlueNeutralFaces(m_blueNeutralFaces, true);
798 setShowHighlightLines(m_showHighlightLines, true);
799 if (m_showHighlightLines)
800 {
801 setEdgesOnly(m_edgesOnly, true);
802 setDrawConditionalHighlights(m_drawConditionalHighlights, true);
803 if (m_drawConditionalHighlights)
804 {
805 setShowAllConditionalLines(m_showAllConditionalLines, true);
806 setShowConditionalControlPoints(m_showConditionalControlPoints,
807 true);
808 }
809 setUsePolygonOffset(m_usePolygonOffset, true);
810 setBlackHighlights(m_blackHighlights, true);
811 }
812 setEdgeThickness(m_edgeThickness, true);
813 if (flush)
814 {
815 TCUserDefaults::flush();
816 }
817 }
818
commitEffectsSettings(bool flush)819 void LDPreferences::commitEffectsSettings(bool flush /*= true*/)
820 {
821 setUseLighting(m_useLighting, true);
822 if (m_useLighting)
823 {
824 setQualityLighting(m_qualityLighting, true);
825 setSubduedLighting(m_subduedLighting, true);
826 setUseSpecular(m_useSpecular, true);
827 setOneLight(m_oneLight, true);
828 setLightVector(m_lightVector, true);
829 setDrawLightDats(m_drawLightDats, true);
830 setOptionalStandardLight(m_optionalStandardLight, true);
831 }
832 // NOTE: lighting doesn't have to be enabled for this one.
833 setNoLightGeom(m_noLightGeom, true);
834 setStereoMode(m_stereoMode, true);
835 setStereoEyeSpacing(m_stereoEyeSpacing, true);
836 setCutawayMode(m_cutawayMode, true);
837 setCutawayAlpha(m_cutawayAlpha, true);
838 setCutawayThickness(m_cutawayThickness, true);
839 setUseStipple(m_useStipple, true);
840 setSortTransparent(m_sortTransparent, true);
841 setUseFlatShading(m_useFlatShading, true);
842 setObi(m_obi, true);
843 setPerformSmoothing(m_performSmoothing, true);
844 if (flush)
845 {
846 TCUserDefaults::flush();
847 }
848 }
849
commitPrimitivesSettings(bool flush)850 void LDPreferences::commitPrimitivesSettings(bool flush /*= true*/)
851 {
852 setAllowPrimitiveSubstitution(m_allowPrimitiveSubstitution, true);
853 if (m_allowPrimitiveSubstitution)
854 {
855 setTextureStuds(m_textureStuds, true);
856 setTextureFilterType(m_textureFilterType, true);
857 setAnisoLevel(m_anisoLevel, true);
858 setCurveQuality(m_curveQuality, true);
859 }
860 setQualityStuds(m_qualityStuds, true);
861 setHiResPrimitives(m_hiResPrimitives, true);
862 setTexmaps(m_texmaps, true);
863 setTextureOffsetFactor(m_textureOffsetFactor, true);
864 setUseStrips(m_useStrips, true);
865 if (flush)
866 {
867 TCUserDefaults::flush();
868 }
869 }
870
commitUpdatesSettings(bool flush)871 void LDPreferences::commitUpdatesSettings(bool flush /*= true*/)
872 {
873 setProxyType(m_proxyType, true);
874 if (m_proxyType == 2)
875 {
876 setProxyServer(m_proxyServer.c_str(), true);
877 setProxyPort(m_proxyPort, true);
878 }
879 setCheckPartTracker(m_checkPartTracker, true);
880 setMissingPartWait(m_missingPartWait, true);
881 setUpdatedPartWait(m_updatedPartWait, true);
882 if (flush)
883 {
884 TCUserDefaults::flush();
885 }
886 }
887
commitInventorySettings(bool flush)888 void LDPreferences::commitInventorySettings(bool flush /*= true*/)
889 {
890 setInvShowModel(m_invShowModel, true);
891 setInvOverwriteSnapshot(m_invOverwriteSnapshot, true);
892 setInvExternalCss(m_invExternalCss, true);
893 setInvPartImages(m_invPartImages, true);
894 setInvShowFile(m_invShowFile, true);
895 setInvShowTotal(m_invShowTotal, true);
896 setInvColumnOrder(m_invColumnOrder, true);
897 //setInvLastSavePath(m_invLastSavePath.c_str(), true);
898 commitSaveDir(SOPartsList);
899 if (flush)
900 {
901 TCUserDefaults::flush();
902 }
903 }
904
setupDefaultRotationMatrix(void)905 void LDPreferences::setupDefaultRotationMatrix(void)
906 {
907 std::string value = getStringSetting(CAMERA_GLOBE_KEY);
908 TCFloat latitude = getFloatSetting(DEFAULT_LATITUDE_KEY, 30.0f);
909 TCFloat longitude = getFloatSetting(DEFAULT_LONGITUDE_KEY, 45.0f);
910
911 if (!value.length())
912 {
913 value = getStringSetting(DEFAULT_LAT_LONG_KEY);
914 }
915 if (value.length())
916 {
917 if (sscanf(value.c_str(), "%f,%f", &latitude, &longitude) == 2)
918 {
919 TCFloat radius = -1;
920 TCFloat resultMatrix[16];
921
922 TCVector::calcRotationMatrix(latitude, longitude, resultMatrix);
923 if (sscanf(value.c_str(), "%*f,%*f,%f", &radius) != 1)
924 {
925 radius = -1;
926 }
927 if (m_modelViewer != NULL)
928 {
929 m_modelViewer->setDefaultRotationMatrix(resultMatrix);
930 if (radius > 0)
931 {
932 m_modelViewer->setDefaultDistance(radius);
933 }
934 }
935 }
936 }
937 else
938 {
939 value = getStringSetting(DEFAULT_MATRIX_KEY);
940 if (value.length())
941 {
942 TCFloat matrix[16];
943
944 memset(matrix, 0, sizeof(matrix));
945 matrix[15] = 1.0f;
946 // ToDo: how to deal with 64-bit float scanf?
947 if (sscanf(value.c_str(), "%f,%f,%f,%f,%f,%f,%f,%f,%f",
948 &matrix[0], &matrix[4], &matrix[8],
949 &matrix[1], &matrix[5], &matrix[9],
950 &matrix[2], &matrix[6], &matrix[10]) == 9)
951 {
952 if (m_modelViewer != NULL)
953 {
954 m_modelViewer->setDefaultRotationMatrix(matrix);
955 }
956 }
957 }
958 }
959 if (m_modelViewer != NULL)
960 {
961 m_modelViewer->setDefaultLatLong(latitude, longitude);
962 }
963 }
964
setupModelCenter(void)965 void LDPreferences::setupModelCenter(void)
966 {
967 std::string value = getStringSetting(MODEL_CENTER_KEY);
968
969 if (value.length())
970 {
971 if (m_modelViewer != NULL)
972 {
973 try {
974 TCVector center(value);
975 m_modelViewer->setModelCenter(center);
976 } catch (...) {
977 // Ignore
978 }
979 }
980 }
981 }
982
setupModelSize(void)983 void LDPreferences::setupModelSize(void)
984 {
985 std::string value = getStringSetting(MODEL_SIZE_KEY);
986
987 if (value.length())
988 {
989 TCFloat size;
990 // ToDo: how to deal with 64-bit float scanf?
991 if (sscanf(value.c_str(), "%f", &size) == 1)
992 {
993 if (m_modelViewer != NULL)
994 {
995 m_modelViewer->setModelSize(size);
996 // If ModelSize is specified, zoom to fit doesn't work or make
997 // sense.
998 m_modelViewer->setForceZoomToFit(false);
999 }
1000 }
1001 }
1002 }
1003
setColorSetting(TCULong & setting,int r,int g,int b,const char * key,bool commit)1004 void LDPreferences::setColorSetting(TCULong &setting, int r, int g, int b,
1005 const char *key, bool commit)
1006 {
1007 TCULong value = getColor(r, g, b);
1008 if (setting != value || (m_changedSettings[key] && commit))
1009 {
1010 setting = value;
1011 if (commit)
1012 {
1013 TCUserDefaults::setLongForKey(setting, key, !m_globalSettings[key]);
1014 m_changedSettings.erase(key);
1015 }
1016 else
1017 {
1018 m_changedSettings[key] = true;
1019 }
1020 }
1021 }
1022
setSetting(StringVector & setting,const StringVector & value,const char * key,bool commit,bool isPath,int keyDigits,int startIndex)1023 void LDPreferences::setSetting(
1024 StringVector &setting,
1025 const StringVector &value,
1026 const char *key,
1027 bool commit,
1028 bool isPath, /*= false*/
1029 int keyDigits /*= 2*/,
1030 int startIndex /*= 0*/)
1031 {
1032 if (setting != value || (m_changedSettings[key] && commit))
1033 {
1034 setting = value;
1035 if (commit)
1036 {
1037 TCUserDefaults::setStringVectorForKey(value, key,
1038 !m_globalSettings[key], isPath, keyDigits, startIndex);
1039 m_changedSettings.erase(key);
1040 }
1041 else if (!m_initializing)
1042 {
1043 m_changedSettings[key] = true;
1044 }
1045 }
1046 }
1047
setSetting(LongVector & setting,const LongVector & value,const char * key,bool commit)1048 void LDPreferences::setSetting(LongVector &setting, const LongVector &value,
1049 const char *key, bool commit)
1050 {
1051 if (setting != value || (m_changedSettings[key] && commit))
1052 {
1053 setting = value;
1054 if (commit)
1055 {
1056 TCUserDefaults::setLongVectorForKey(value, key,
1057 !m_globalSettings[key]);
1058 m_changedSettings.erase(key);
1059 }
1060 else if (!m_initializing)
1061 {
1062 m_changedSettings[key] = true;
1063 }
1064 }
1065 }
1066
setSetting(TCVector & setting,const TCVector & value,const char * key,bool commit)1067 bool LDPreferences::setSetting(TCVector &setting, const TCVector &value,
1068 const char *key, bool commit)
1069 {
1070 if (setting != value || (m_changedSettings[key] && commit))
1071 {
1072 setting = value;
1073 if (commit)
1074 {
1075 char stringValue[128];
1076
1077 sprintf(stringValue, "%f,%f,%f", value.get(0), value.get(1),
1078 value.get(2));
1079 TCUserDefaults::setStringForKey(stringValue, key,
1080 !m_globalSettings[key]);
1081 m_changedSettings.erase(key);
1082 }
1083 else if (!m_initializing)
1084 {
1085 m_changedSettings[key] = true;
1086 }
1087 return true;
1088 }
1089 return false;
1090 }
1091
setSetting(bool & setting,bool value,const char * key,bool commit)1092 void LDPreferences::setSetting(bool &setting, bool value, const char *key,
1093 bool commit)
1094 {
1095 if (setting != value || (m_changedSettings[key] && commit))
1096 {
1097 setting = value;
1098 if (commit)
1099 {
1100 TCUserDefaults::setLongForKey(value ? 1 : 0, key,
1101 !m_globalSettings[key]);
1102 m_changedSettings.erase(key);
1103 }
1104 else if (!m_initializing)
1105 {
1106 m_changedSettings[key] = true;
1107 }
1108 }
1109 }
1110
setSetting(int & setting,int value,const char * key,bool commit)1111 void LDPreferences::setSetting(int &setting, int value, const char *key,
1112 bool commit)
1113 {
1114 if (setting != value || (m_changedSettings[key] && commit))
1115 {
1116 setting = value;
1117 if (commit)
1118 {
1119 TCUserDefaults::setLongForKey(value, key, !m_globalSettings[key]);
1120 m_changedSettings.erase(key);
1121 }
1122 else if (!m_initializing)
1123 {
1124 m_changedSettings[key] = true;
1125 }
1126 }
1127 }
1128
setSetting(TCULong & setting,TCULong value,const char * key,bool commit)1129 void LDPreferences::setSetting(TCULong &setting, TCULong value, const char *key,
1130 bool commit)
1131 {
1132 if (setting != value || (m_changedSettings[key] && commit))
1133 {
1134 setting = value;
1135 if (commit)
1136 {
1137 TCUserDefaults::setLongForKey((long)value, key,
1138 !m_globalSettings[key]);
1139 m_changedSettings.erase(key);
1140 }
1141 else if (!m_initializing)
1142 {
1143 m_changedSettings[key] = true;
1144 }
1145 }
1146 }
1147
setSetting(TCFloat & setting,TCFloat value,const char * key,bool commit)1148 void LDPreferences::setSetting(TCFloat &setting, TCFloat value, const char *key,
1149 bool commit)
1150 {
1151 if (setting != value || (m_changedSettings[key] && commit))
1152 {
1153 setting = value;
1154 if (commit)
1155 {
1156 TCUserDefaults::setFloatForKey(value, key, !m_globalSettings[key]);
1157 m_changedSettings.erase(key);
1158 }
1159 else if (!m_initializing)
1160 {
1161 m_changedSettings[key] = true;
1162 }
1163 }
1164 }
1165
setSetting(std::string & setting,const std::string & value,const char * key,bool commit,bool isPath)1166 void LDPreferences::setSetting(
1167 std::string &setting,
1168 const std::string &value,
1169 const char *key,
1170 bool commit,
1171 bool isPath /*= false*/)
1172 {
1173 if (setting != value || (m_changedSettings[key] && commit))
1174 {
1175 setting = value;
1176 if (commit)
1177 {
1178 if (isPath)
1179 {
1180 TCUserDefaults::setPathForKey(value.c_str(), key,
1181 !m_globalSettings[key]);
1182 }
1183 else
1184 {
1185 TCUserDefaults::setStringForKey(value.c_str(), key,
1186 !m_globalSettings[key]);
1187 }
1188 m_changedSettings.erase(key);
1189 }
1190 else if (!m_initializing)
1191 {
1192 m_changedSettings[key] = true;
1193 }
1194 }
1195 }
1196
getBoolSetting(const char * key,bool defaultValue)1197 bool LDPreferences::getBoolSetting(const char *key, bool defaultValue)
1198 {
1199 return TCUserDefaults::longForKey(key, (long)defaultValue,
1200 !m_globalSettings[key]) != 0;
1201 }
1202
getLongVectorSetting(const char * key,const LongVector & defaultValue)1203 LongVector LDPreferences::getLongVectorSetting(
1204 const char *key,
1205 const LongVector &defaultValue)
1206 {
1207 return TCUserDefaults::longVectorForKey(key, defaultValue,
1208 !m_globalSettings[key]);
1209 }
1210
getStringVectorSetting(const char * key,const StringVector & defaultValue,bool isPath,int keyDigits,int startIndex)1211 StringVector LDPreferences::getStringVectorSetting(
1212 const char *key,
1213 const StringVector &defaultValue,
1214 bool isPath, /*= false*/
1215 int keyDigits /*= 2*/,
1216 int startIndex /*= 0*/)
1217 {
1218 return TCUserDefaults::stringVectorForKey(key, defaultValue,
1219 !m_globalSettings[key], isPath, keyDigits, startIndex);
1220 }
1221
getTCVectorSetting(const char * key,const TCVector & defaultValue)1222 TCVector LDPreferences::getTCVectorSetting(const char *key,
1223 const TCVector &defaultValue)
1224 {
1225 std::string vectorString;
1226
1227 vectorString = getStringSetting(key);
1228 if (vectorString.length())
1229 {
1230 TCFloat lx, ly, lz;
1231
1232 // ToDo: how to deal with 64-bit float scanf?
1233 if (sscanf(vectorString.c_str(), "%f,%f,%f", &lx, &ly, &lz) == 3)
1234 {
1235 return TCVector(lx, ly, lz);
1236 }
1237 }
1238 return defaultValue;
1239 }
1240
getLongSetting(const char * key,long defaultValue)1241 long LDPreferences::getLongSetting(const char *key, long defaultValue)
1242 {
1243 return TCUserDefaults::longForKey(key, defaultValue, !m_globalSettings[key]);
1244 }
1245
getIntSetting(const char * key,int defaultValue)1246 int LDPreferences::getIntSetting(const char *key, int defaultValue)
1247 {
1248 return (int)TCUserDefaults::longForKey(key, defaultValue,
1249 !m_globalSettings[key]);
1250 }
1251
getFloatSetting(const char * key,float defaultValue)1252 float LDPreferences::getFloatSetting(const char *key, float defaultValue)
1253 {
1254 return TCUserDefaults::floatForKey(key, defaultValue, !m_globalSettings[key]);
1255 }
1256
getStringSetting(const char * key,const char * defaultValue,bool isPath)1257 std::string LDPreferences::getStringSetting(
1258 const char *key,
1259 const char *defaultValue /*= NULL*/,
1260 bool isPath /*= false*/)
1261 {
1262 char *tmpString;
1263 std::string result;
1264
1265 if (isPath)
1266 {
1267 tmpString = TCUserDefaults::pathForKey(key, defaultValue,
1268 !m_globalSettings[key]);
1269 }
1270 else
1271 {
1272 tmpString = TCUserDefaults::stringForKey(key, defaultValue,
1273 !m_globalSettings[key]);
1274 }
1275 if (tmpString)
1276 {
1277 result = tmpString;
1278 delete[] tmpString;
1279 }
1280 return result;
1281 }
1282
1283 // General settings
setFsaaMode(int value,bool commit)1284 void LDPreferences::setFsaaMode(int value, bool commit)
1285 {
1286 setSetting(m_fsaaMode, value, FSAA_MODE_KEY, commit);
1287 }
1288
setLineSmoothing(bool value,bool commit)1289 void LDPreferences::setLineSmoothing(bool value, bool commit)
1290 {
1291 setSetting(m_lineSmoothing, value, LINE_SMOOTHING_KEY, commit);
1292 }
1293
setBackgroundColor(int r,int g,int b,bool commit)1294 void LDPreferences::setBackgroundColor(int r, int g, int b, bool commit)
1295 {
1296 setColorSetting(m_backgroundColor, r, g, b, BACKGROUND_COLOR_KEY, commit);
1297 }
1298
setDefaultColor(int r,int g,int b,bool commit)1299 void LDPreferences::setDefaultColor(int r, int g, int b, bool commit)
1300 {
1301 setColorSetting(m_defaultColor, r, g, b, DEFAULT_COLOR_KEY, commit);
1302 }
1303
setTransDefaultColor(bool value,bool commit,bool apply)1304 void LDPreferences::setTransDefaultColor(bool value, bool commit, bool apply)
1305 {
1306 setSetting(m_transDefaultColor, value, TRANS_DEFAULT_COLOR_KEY, commit);
1307 if (apply && m_modelViewer != NULL)
1308 {
1309 int r, g, b;
1310
1311 getRGB(m_defaultColor, r, g, b);
1312 m_modelViewer->setDefaultRGB((TCByte)r, (TCByte)g, (TCByte)b,
1313 m_transDefaultColor);
1314 }
1315 }
1316
setProcessLdConfig(bool value,bool commit)1317 void LDPreferences::setProcessLdConfig(bool value, bool commit)
1318 {
1319 setSetting(m_processLdConfig, value, PROCESS_LDCONFIG_KEY, commit);
1320 }
1321
setRandomColors(bool value,bool commit,bool apply)1322 void LDPreferences::setRandomColors(bool value, bool commit, bool apply)
1323 {
1324 setSetting(m_randomColors, value, RANDOM_COLORS_KEY, commit);
1325 if (apply && m_modelViewer != NULL)
1326 {
1327 m_modelViewer->setRandomColors(value);
1328 }
1329 }
1330
setShowFps(bool value,bool commit)1331 void LDPreferences::setShowFps(bool value, bool commit)
1332 {
1333 setSetting(m_showFps, value, SHOW_FPS_KEY, commit);
1334 }
1335
setShowAxes(bool value,bool commit,bool apply)1336 void LDPreferences::setShowAxes(bool value, bool commit, bool apply)
1337 {
1338 setSetting(m_showAxes, value, SHOW_AXES_KEY, commit);
1339 if (apply && m_modelViewer != NULL)
1340 {
1341 m_modelViewer->setShowAxes(value);
1342 }
1343 }
1344
setShowErrors(bool value,bool commit)1345 void LDPreferences::setShowErrors(bool value, bool commit)
1346 {
1347 setSetting(m_showErrors, value, SHOW_ERRORS_KEY, commit);
1348 }
1349
setDisableSmp(bool value,bool commit)1350 void LDPreferences::setDisableSmp(bool value, bool commit)
1351 {
1352 setSetting(m_multiThreaded, !value, MULTI_THREADED_KEY, commit);
1353 }
1354
setFullScreenRefresh(int value,bool commit)1355 void LDPreferences::setFullScreenRefresh(int value, bool commit)
1356 {
1357 setSetting(m_fullScreenRefresh, value, FULLSCREEN_REFRESH_KEY, commit);
1358 }
1359
setFov(TCFloat value,bool commit)1360 void LDPreferences::setFov(TCFloat value, bool commit)
1361 {
1362 setSetting(m_fov, value, FOV_KEY, commit);
1363 }
1364
setMemoryUsage(int value,bool commit)1365 void LDPreferences::setMemoryUsage(int value, bool commit)
1366 {
1367 setSetting(m_memoryUsage, value, MEMORY_USAGE_KEY, commit);
1368 }
1369
setCustomColor(int index,int r,int g,int b,bool commit)1370 void LDPreferences::setCustomColor(int index, int r, int g, int b, bool commit)
1371 {
1372 char key[128];
1373
1374 sprintf(key, "%s/Color%02d", CUSTOM_COLORS_KEY, index);
1375 setColorSetting(m_customColors[index], r, g, b, key, commit);
1376 }
1377
setSaveDirMode(SaveOp op,DefaultDirMode value,bool commit)1378 void LDPreferences::setSaveDirMode(
1379 SaveOp op,
1380 DefaultDirMode value,
1381 bool commit /*= false*/)
1382 {
1383 DefaultDirMode &mode = m_saveDirModes[op];
1384 int intMode = mode;
1385
1386 setSetting(intMode, value, m_saveDirModeKeys[op].c_str(), commit);
1387 mode = (DefaultDirMode)intMode;
1388 }
1389
setSaveDir(SaveOp op,const char * value,bool commit)1390 void LDPreferences::setSaveDir(
1391 SaveOp op,
1392 const char *value,
1393 bool commit /*= false*/)
1394 {
1395 setSetting(m_saveDirs[op], value, m_saveDirKeys[op].c_str(), commit, true);
1396 }
1397
setLastSaveDir(SaveOp op,const char * value,bool commit)1398 void LDPreferences::setLastSaveDir(
1399 SaveOp op,
1400 const char *value,
1401 bool commit /*= false*/)
1402 {
1403 setSetting(m_lastSaveDirs[op], value, m_lastSaveDirKeys[op].c_str(), commit,
1404 true);
1405 }
1406
1407 //void LDPreferences::setSnapshotsDirMode(
1408 // DefaultDirMode value,
1409 // bool commit /*= false*/)
1410 //{
1411 // int intValue = m_snapshotsDirMode;
1412 //
1413 // setSetting(intValue, value, SNAPSHOTS_DIR_MODE_KEY, commit);
1414 // m_snapshotsDirMode = (DefaultDirMode)intValue;
1415 //}
1416 //
1417 //void LDPreferences::setSnapshotsDir(const char *value, bool commit)
1418 //{
1419 // setSetting(m_snapshotsDir, value, SNAPSHOTS_DIR_KEY, commit);
1420 //}
1421 //
1422 //void LDPreferences::setPartsListsDirMode(
1423 // DefaultDirMode value,
1424 // bool commit /*= false*/)
1425 //{
1426 // int intValue = m_partsListsDirMode;
1427 //
1428 // setSetting(intValue, value, PARTS_LISTS_DIR_MODE_KEY, commit);
1429 // m_partsListsDirMode = (DefaultDirMode)intValue;
1430 //}
1431 //
1432 //void LDPreferences::setPartsListsDir(const char *value, bool commit)
1433 //{
1434 // setSetting(m_partsListsDir, value, PARTS_LISTS_DIR_KEY, commit);
1435 //}
1436
1437 // LDraw settings
setLDrawDir(const char * value,bool commit)1438 void LDPreferences::setLDrawDir(const char *value, bool commit)
1439 {
1440 setSetting(m_ldrawDir, value, LDRAWDIR_KEY, commit);
1441 }
1442
setExtraDirs(const StringVector & value,bool commit)1443 void LDPreferences::setExtraDirs(
1444 const StringVector &value,
1445 bool commit)
1446 {
1447 std::string dirKey = std::string(EXTRA_SEARCH_DIRS_KEY) + "/Dir";
1448 setSetting(m_extraDirs, value, dirKey.c_str(), commit, true, 3, 1);
1449 }
1450
1451 // Geometry settings
setUseSeams(bool value,bool commit,bool apply)1452 void LDPreferences::setUseSeams(bool value, bool commit, bool apply)
1453 {
1454 setSetting(m_useSeams, value, SEAMS_KEY, commit);
1455 if (apply && m_modelViewer != NULL)
1456 {
1457 if (m_useSeams)
1458 {
1459 m_modelViewer->setSeamWidth(m_seamWidth / 100.0f);
1460 }
1461 else
1462 {
1463 m_modelViewer->setSeamWidth(0.0f);
1464 }
1465 }
1466 }
1467
setSeamWidth(int value,bool commit)1468 void LDPreferences::setSeamWidth(int value, bool commit)
1469 {
1470 setSetting(m_seamWidth, value, SEAM_WIDTH_KEY, commit);
1471 }
1472
setBoundingBoxesOnly(bool value,bool commit,bool apply)1473 void LDPreferences::setBoundingBoxesOnly(bool value, bool commit, bool apply)
1474 {
1475 setSetting(m_boundingBoxesOnly, value, BOUNDING_BOXES_ONLY_KEY, commit);
1476 if (apply && m_modelViewer != NULL)
1477 {
1478 m_modelViewer->setBoundingBoxesOnly(m_boundingBoxesOnly);
1479 }
1480 }
1481
setDrawWireframe(bool value,bool commit,bool apply)1482 void LDPreferences::setDrawWireframe(bool value, bool commit, bool apply)
1483 {
1484 setSetting(m_drawWireframe, value, WIREFRAME_KEY, commit);
1485 if (apply && m_modelViewer != NULL)
1486 {
1487 m_modelViewer->setDrawWireframe(m_drawWireframe);
1488 }
1489 }
1490
setUseWireframeFog(bool value,bool commit,bool apply)1491 void LDPreferences::setUseWireframeFog(bool value, bool commit, bool apply)
1492 {
1493 setSetting(m_useWireframeFog, value, WIREFRAME_FOG_KEY, commit);
1494 if (apply && m_modelViewer != NULL)
1495 {
1496 m_modelViewer->setUseWireframeFog(m_useWireframeFog);
1497 }
1498 }
1499
setRemoveHiddenLines(bool value,bool commit,bool apply)1500 void LDPreferences::setRemoveHiddenLines(bool value, bool commit, bool apply)
1501 {
1502 setSetting(m_removeHiddenLines, value, REMOVE_HIDDEN_LINES_KEY, commit);
1503 if (apply && m_modelViewer != NULL)
1504 {
1505 m_modelViewer->setRemoveHiddenLines(m_removeHiddenLines);
1506 }
1507 }
1508
setWireframeThickness(int value,bool commit)1509 void LDPreferences::setWireframeThickness(int value, bool commit)
1510 {
1511 setSetting(m_wireframeThickness, value, WIREFRAME_THICKNESS_KEY, commit);
1512 }
1513
setBfc(bool value,bool commit,bool apply)1514 void LDPreferences::setBfc(bool value, bool commit, bool apply)
1515 {
1516 setSetting(m_bfc, value, BFC_KEY, commit);
1517 if (apply && m_modelViewer != NULL)
1518 {
1519 m_modelViewer->setBfc(m_bfc);
1520 }
1521 }
1522
setRedBackFaces(bool value,bool commit,bool apply)1523 void LDPreferences::setRedBackFaces(bool value, bool commit, bool apply)
1524 {
1525 setSetting(m_redBackFaces, value, RED_BACK_FACES_KEY, commit);
1526 if (apply && m_modelViewer != NULL)
1527 {
1528 m_modelViewer->setRedBackFaces(m_redBackFaces);
1529 }
1530 }
1531
setGreenFrontFaces(bool value,bool commit,bool apply)1532 void LDPreferences::setGreenFrontFaces(bool value, bool commit, bool apply)
1533 {
1534 setSetting(m_greenFrontFaces, value, GREEN_FRONT_FACES_KEY, commit);
1535 if (apply && m_modelViewer != NULL)
1536 {
1537 m_modelViewer->setGreenFrontFaces(m_greenFrontFaces);
1538 }
1539 }
1540
setBlueNeutralFaces(bool value,bool commit,bool apply)1541 void LDPreferences::setBlueNeutralFaces(bool value, bool commit, bool apply)
1542 {
1543 setSetting(m_blueNeutralFaces, value, BLUE_NEUTRAL_FACES_KEY, commit);
1544 if (apply && m_modelViewer != NULL)
1545 {
1546 m_modelViewer->setBlueNeutralFaces(m_blueNeutralFaces);
1547 }
1548 }
1549
setShowHighlightLines(bool value,bool commit,bool apply)1550 void LDPreferences::setShowHighlightLines(bool value, bool commit, bool apply)
1551 {
1552 setSetting(m_showHighlightLines, value, SHOW_HIGHLIGHT_LINES_KEY, commit);
1553 if (apply && m_modelViewer != NULL)
1554 {
1555 m_modelViewer->setShowsHighlightLines(m_showHighlightLines);
1556 }
1557 }
1558
setDrawConditionalHighlights(bool value,bool commit,bool apply)1559 void LDPreferences::setDrawConditionalHighlights(bool value, bool commit,
1560 bool apply)
1561 {
1562 setSetting(m_drawConditionalHighlights, value, CONDITIONAL_HIGHLIGHTS_KEY,
1563 commit);
1564 if (apply && m_modelViewer != NULL)
1565 {
1566 m_modelViewer->setDrawConditionalHighlights(
1567 m_drawConditionalHighlights);
1568 }
1569 }
1570
setShowAllConditionalLines(bool value,bool commit,bool apply)1571 void LDPreferences::setShowAllConditionalLines(
1572 bool value,
1573 bool commit,
1574 bool apply)
1575 {
1576 setSetting(m_showAllConditionalLines, value, SHOW_ALL_TYPE5_KEY, commit);
1577 if (apply && m_modelViewer != NULL)
1578 {
1579 m_modelViewer->setShowAllConditionalLines(m_showAllConditionalLines);
1580 }
1581 }
1582
setShowConditionalControlPoints(bool value,bool commit,bool apply)1583 void LDPreferences::setShowConditionalControlPoints(
1584 bool value,
1585 bool commit,
1586 bool apply)
1587 {
1588 setSetting(m_showConditionalControlPoints, value,
1589 SHOW_TYPE5_CONTROL_POINTS_KEY, commit);
1590 if (apply && m_modelViewer != NULL)
1591 {
1592 m_modelViewer->setShowConditionalControlPoints(
1593 m_showConditionalControlPoints);
1594 }
1595 }
1596
setEdgesOnly(bool value,bool commit,bool apply)1597 void LDPreferences::setEdgesOnly(bool value, bool commit, bool apply)
1598 {
1599 setSetting(m_edgesOnly, value, EDGES_ONLY_KEY, commit);
1600 if (apply && m_modelViewer != NULL)
1601 {
1602 m_modelViewer->setEdgesOnly(m_edgesOnly);
1603 }
1604 }
1605
setUsePolygonOffset(bool value,bool commit,bool apply)1606 void LDPreferences::setUsePolygonOffset(bool value, bool commit, bool apply)
1607 {
1608 setSetting(m_usePolygonOffset, value, POLYGON_OFFSET_KEY, commit);
1609 if (apply && m_modelViewer != NULL)
1610 {
1611 m_modelViewer->setUsePolygonOffset(m_usePolygonOffset);
1612 }
1613 }
1614
setBlackHighlights(bool value,bool commit,bool apply)1615 void LDPreferences::setBlackHighlights(bool value, bool commit, bool apply)
1616 {
1617 setSetting(m_blackHighlights, value, BLACK_HIGHLIGHTS_KEY, commit);
1618 if (apply && m_modelViewer != NULL)
1619 {
1620 m_modelViewer->setBlackHighlights(m_blackHighlights);
1621 }
1622 }
1623
setEdgeThickness(int value,bool commit)1624 void LDPreferences::setEdgeThickness(int value, bool commit)
1625 {
1626 setSetting(m_edgeThickness, value, EDGE_THICKNESS_KEY, commit);
1627 }
1628
1629
1630 // Effects settings
setUseLighting(bool value,bool commit,bool apply)1631 void LDPreferences::setUseLighting(bool value, bool commit, bool apply)
1632 {
1633 setSetting(m_useLighting, value, LIGHTING_KEY, commit);
1634 if (apply && m_modelViewer != NULL)
1635 {
1636 m_modelViewer->setUseLighting(m_useLighting);
1637 }
1638 }
1639
setQualityLighting(bool value,bool commit,bool apply)1640 void LDPreferences::setQualityLighting(bool value, bool commit, bool apply)
1641 {
1642 setSetting(m_qualityLighting, value, QUALITY_LIGHTING_KEY, commit);
1643 if (apply && m_modelViewer != NULL)
1644 {
1645 m_modelViewer->setQualityLighting(m_qualityLighting);
1646 }
1647 }
1648
setSubduedLighting(bool value,bool commit,bool apply)1649 void LDPreferences::setSubduedLighting(bool value, bool commit, bool apply)
1650 {
1651 setSetting(m_subduedLighting, value, SUBDUED_LIGHTING_KEY, commit);
1652 if (apply && m_modelViewer != NULL)
1653 {
1654 m_modelViewer->setSubduedLighting(m_subduedLighting);
1655 }
1656 }
1657
setUseSpecular(bool value,bool commit,bool apply)1658 void LDPreferences::setUseSpecular(bool value, bool commit, bool apply)
1659 {
1660 setSetting(m_useSpecular, value, SPECULAR_KEY, commit);
1661 if (apply && m_modelViewer != NULL)
1662 {
1663 m_modelViewer->setUsesSpecular(m_useSpecular);
1664 }
1665 }
1666
setOneLight(bool value,bool commit,bool apply)1667 void LDPreferences::setOneLight(bool value, bool commit, bool apply)
1668 {
1669 setSetting(m_oneLight, value, ONE_LIGHT_KEY, commit);
1670 if (apply && m_modelViewer != NULL)
1671 {
1672 m_modelViewer->setOneLight(m_oneLight);
1673 }
1674 }
1675
setDrawLightDats(bool value,bool commit,bool apply)1676 void LDPreferences::setDrawLightDats(bool value, bool commit, bool apply)
1677 {
1678 setSetting(m_drawLightDats, value, DRAW_LIGHT_DATS_KEY, commit);
1679 if (apply && m_modelViewer != NULL)
1680 {
1681 m_modelViewer->setDrawLightDats(m_drawLightDats);
1682 }
1683 }
1684
setOptionalStandardLight(bool value,bool commit,bool apply)1685 void LDPreferences::setOptionalStandardLight(bool value, bool commit,
1686 bool apply)
1687 {
1688 setSetting(m_optionalStandardLight, value, OPTIONAL_STANDARD_LIGHT_KEY,
1689 commit);
1690 if (apply && m_modelViewer != NULL)
1691 {
1692 m_modelViewer->setOptionalStandardLight(m_optionalStandardLight);
1693 }
1694 }
1695
setNoLightGeom(bool value,bool commit,bool apply)1696 void LDPreferences::setNoLightGeom(bool value, bool commit, bool apply)
1697 {
1698 setSetting(m_noLightGeom, value, NO_LIGHT_GEOM_KEY, commit);
1699 if (apply && m_modelViewer != NULL)
1700 {
1701 m_modelViewer->setNoLightGeom(m_noLightGeom);
1702 }
1703 }
1704
setLightDirection(LightDirection value,bool commit,bool apply)1705 void LDPreferences::setLightDirection(LightDirection value, bool commit,
1706 bool apply)
1707 {
1708 TCVector lightVector;
1709
1710 switch (value)
1711 {
1712 case UpperLeft:
1713 lightVector = TCVector(-1.0f, 1.0f, 1.0f);
1714 break;
1715 case UpperMiddle:
1716 lightVector = TCVector(0.0f, 1.0f, 1.0f);
1717 break;
1718 case UpperRight:
1719 lightVector = TCVector(1.0f, 1.0f, 1.0f);
1720 break;
1721 case MiddleLeft:
1722 lightVector = TCVector(-1.0f, 0.0f, 1.0f);
1723 break;
1724 case MiddleRight:
1725 lightVector = TCVector(1.0f, 0.0f, 1.0f);
1726 break;
1727 case LowerLeft:
1728 lightVector = TCVector(-1.0f, -1.0f, 1.0f);
1729 break;
1730 case LowerMiddle:
1731 lightVector = TCVector(0.0f, -1.0f, 1.0f);
1732 break;
1733 case LowerRight:
1734 lightVector = TCVector(1.0f, -1.0f, 1.0f);
1735 break;
1736 default:
1737 lightVector = TCVector(0.0f, 0.0f, 1.0f);
1738 break;
1739 }
1740 setLightVector(lightVector, commit, apply);
1741 }
1742
setLightVector(const TCVector & value,bool commit,bool apply)1743 void LDPreferences::setLightVector(const TCVector &value, bool commit,
1744 bool apply)
1745 {
1746 if (setSetting(m_lightVector, value, LIGHT_VECTOR_KEY, commit))
1747 {
1748 TCAlertManager::sendAlert(lightVectorChangedAlertClass(), this);
1749 }
1750 if (apply && m_modelViewer != NULL)
1751 {
1752 m_modelViewer->setLightVector(m_lightVector);
1753 }
1754 }
1755
setStereoMode(LDVStereoMode value,bool commit)1756 void LDPreferences::setStereoMode(LDVStereoMode value, bool commit)
1757 {
1758 int temp = (int)m_stereoMode;
1759
1760 setSetting(temp, value, STEREO_MODE_KEY, commit);
1761 m_stereoMode = (LDVStereoMode)temp;
1762 }
1763
setStereoEyeSpacing(int value,bool commit)1764 void LDPreferences::setStereoEyeSpacing(int value, bool commit)
1765 {
1766 setSetting(m_stereoEyeSpacing, value, STEREO_SPACING_KEY, commit);
1767 }
1768
setCutawayMode(LDVCutawayMode value,bool commit,bool apply)1769 void LDPreferences::setCutawayMode(
1770 LDVCutawayMode value,
1771 bool commit,
1772 bool apply)
1773 {
1774 int temp = (int)m_cutawayMode;
1775
1776 setSetting(temp, value, CUTAWAY_MODE_KEY, commit);
1777 m_cutawayMode = (LDVCutawayMode)temp;
1778 if (apply && m_modelViewer != NULL)
1779 {
1780 m_modelViewer->setCutawayMode(m_cutawayMode);
1781 }
1782 }
1783
setCutawayAlpha(int value,bool commit)1784 void LDPreferences::setCutawayAlpha(int value, bool commit)
1785 {
1786 setSetting(m_cutawayAlpha, value, CUTAWAY_ALPHA_KEY, commit);
1787 }
1788
setCutawayThickness(int value,bool commit)1789 void LDPreferences::setCutawayThickness(int value, bool commit)
1790 {
1791 setSetting(m_cutawayThickness, value, CUTAWAY_THICKNESS_KEY, commit);
1792 }
1793
setSortTransparent(bool value,bool commit)1794 void LDPreferences::setSortTransparent(bool value, bool commit)
1795 {
1796 setSetting(m_sortTransparent, value, SORT_KEY, commit);
1797 }
1798
setPerformSmoothing(bool value,bool commit,bool apply)1799 void LDPreferences::setPerformSmoothing(bool value, bool commit, bool apply)
1800 {
1801 setSetting(m_performSmoothing, value, PERFORM_SMOOTHING_KEY, commit);
1802 if (apply && m_modelViewer != NULL)
1803 {
1804 m_modelViewer->setPerformSmoothing(m_performSmoothing);
1805 }
1806 }
1807
setUseStipple(bool value,bool commit)1808 void LDPreferences::setUseStipple(bool value, bool commit)
1809 {
1810 setSetting(m_useStipple, value, STIPPLE_KEY, commit);
1811 }
1812
setUseFlatShading(bool value,bool commit,bool apply)1813 void LDPreferences::setUseFlatShading(bool value, bool commit, bool apply)
1814 {
1815 setSetting(m_useFlatShading, value, FLAT_SHADING_KEY, commit);
1816 if (apply && m_modelViewer != NULL)
1817 {
1818 m_modelViewer->setUsesFlatShading(m_useFlatShading);
1819 }
1820 }
1821
setObi(bool value,bool commit)1822 void LDPreferences::setObi(bool value, bool commit)
1823 {
1824 setSetting(m_obi, value, OBI_KEY, commit);
1825 }
1826
1827
1828 // Primitives settings
setAllowPrimitiveSubstitution(bool value,bool commit,bool apply)1829 void LDPreferences::setAllowPrimitiveSubstitution(bool value, bool commit,
1830 bool apply)
1831 {
1832 setSetting(m_allowPrimitiveSubstitution, value, PRIMITIVE_SUBSTITUTION_KEY,
1833 commit);
1834 if (apply && m_modelViewer != NULL)
1835 {
1836 m_modelViewer->setAllowPrimitiveSubstitution(
1837 m_allowPrimitiveSubstitution);
1838 }
1839 }
1840
setTextureStuds(bool value,bool commit,bool apply)1841 void LDPreferences::setTextureStuds(bool value, bool commit, bool apply)
1842 {
1843 setSetting(m_textureStuds, value, TEXTURE_STUDS_KEY, commit);
1844 if (apply && m_modelViewer != NULL)
1845 {
1846 m_modelViewer->setTextureStuds(m_textureStuds);
1847 }
1848 }
1849
setTextureFilterType(int value,bool commit)1850 void LDPreferences::setTextureFilterType(int value, bool commit)
1851 {
1852 setSetting(m_textureFilterType, value, TEXTURE_FILTER_TYPE_KEY, commit);
1853 }
1854
setAnisoLevel(TCFloat value,bool commit)1855 void LDPreferences::setAnisoLevel(TCFloat value, bool commit)
1856 {
1857 setSetting(m_anisoLevel, value, ANISO_LEVEL_KEY, commit);
1858 }
1859
setCurveQuality(int value,bool commit)1860 void LDPreferences::setCurveQuality(int value, bool commit)
1861 {
1862 setSetting(m_curveQuality, value, CURVE_QUALITY_KEY, commit);
1863 }
1864
setQualityStuds(bool value,bool commit,bool apply)1865 void LDPreferences::setQualityStuds(bool value, bool commit, bool apply)
1866 {
1867 setSetting(m_qualityStuds, value, QUALITY_STUDS_KEY, commit);
1868 if (apply && m_modelViewer != NULL)
1869 {
1870 m_modelViewer->setQualityStuds(m_qualityStuds);
1871 }
1872 }
1873
setHiResPrimitives(bool value,bool commit)1874 void LDPreferences::setHiResPrimitives(bool value, bool commit)
1875 {
1876 setSetting(m_hiResPrimitives, value, HI_RES_PRIMITIVES_KEY, commit);
1877 }
1878
setTexmaps(bool value,bool commit,bool apply)1879 void LDPreferences::setTexmaps(bool value, bool commit, bool apply)
1880 {
1881 setSetting(m_texmaps, value, TEXMAPS_KEY, commit);
1882 if (apply && m_modelViewer != NULL)
1883 {
1884 m_modelViewer->setTexmaps(m_texmaps);
1885 }
1886 }
1887
setTexturesAfterTransparent(bool,bool,bool)1888 void LDPreferences::setTexturesAfterTransparent(bool /*value*/, bool /*commit*/, bool /*apply*/)
1889 {
1890 }
1891
setTextureOffsetFactor(TCFloat value,bool commit,bool apply)1892 void LDPreferences::setTextureOffsetFactor(TCFloat value, bool commit, bool apply)
1893 {
1894 setSetting(m_textureOffsetFactor, value, TEXTURE_OFFSET_FACTOR_KEY, commit);
1895 if (apply && m_modelViewer != NULL)
1896 {
1897 m_modelViewer->setTextureOffsetFactor(value);
1898 }
1899 }
1900
setUseStrips(bool value,bool commit,bool apply)1901 void LDPreferences::setUseStrips(bool value, bool commit, bool apply)
1902 {
1903 setSetting(m_useStrips, value, STRIPS_KEY, commit);
1904 if (apply && m_modelViewer != NULL)
1905 {
1906 m_modelViewer->setUseStrips(m_useStrips);
1907 }
1908 }
1909
1910 // Update settings
setProxyType(int value,bool commit)1911 void LDPreferences::setProxyType(int value, bool commit)
1912 {
1913 setSetting(m_proxyType, value, PROXY_TYPE_KEY, commit);
1914 }
1915
setProxyServer(const char * value,bool commit)1916 void LDPreferences::setProxyServer(const char *value, bool commit)
1917 {
1918 setSetting(m_proxyServer, value, PROXY_SERVER_KEY, commit);
1919 }
1920
setProxyPort(int value,bool commit)1921 void LDPreferences::setProxyPort(int value, bool commit)
1922 {
1923 setSetting(m_proxyPort, value, PROXY_PORT_KEY, commit);
1924 }
1925
setCheckPartTracker(bool value,bool commit)1926 void LDPreferences::setCheckPartTracker(bool value, bool commit)
1927 {
1928 setSetting(m_checkPartTracker, value, CHECK_PART_TRACKER_KEY, commit);
1929 }
1930
setMissingPartWait(int value,bool commit)1931 void LDPreferences::setMissingPartWait(int value, bool commit)
1932 {
1933 setSetting(m_missingPartWait, value, CHECK_PART_WAIT_KEY, commit);
1934 }
1935
setUpdatedPartWait(int value,bool commit)1936 void LDPreferences::setUpdatedPartWait(int value, bool commit)
1937 {
1938 setSetting(m_updatedPartWait, value, CHECK_PART_UPDATE_WAIT_KEY, commit);
1939 }
1940
setInvShowModel(bool value,bool commit)1941 void LDPreferences::setInvShowModel(bool value, bool commit)
1942 {
1943 setSetting(m_invShowModel, value, INV_SHOW_MODEL_KEY, commit);
1944 }
1945
setInvOverwriteSnapshot(bool value,bool commit)1946 void LDPreferences::setInvOverwriteSnapshot(bool value, bool commit)
1947 {
1948 setSetting(m_invOverwriteSnapshot, value, INV_OVERWRITE_SNAPSHOT_KEY,
1949 commit);
1950 }
1951
setInvExternalCss(bool value,bool commit)1952 void LDPreferences::setInvExternalCss(bool value, bool commit)
1953 {
1954 setSetting(m_invExternalCss, value, INV_EXTERNAL_CSS_KEY, commit);
1955 }
1956
setInvPartImages(bool value,bool commit)1957 void LDPreferences::setInvPartImages(bool value, bool commit)
1958 {
1959 setSetting(m_invPartImages, value, INV_PART_IMAGES_KEY, commit);
1960 }
1961
setInvShowFile(bool value,bool commit)1962 void LDPreferences::setInvShowFile(bool value, bool commit)
1963 {
1964 setSetting(m_invShowFile, value, INV_SHOW_FILE_KEY, commit);
1965 }
1966
setInvShowTotal(bool value,bool commit)1967 void LDPreferences::setInvShowTotal(bool value, bool commit)
1968 {
1969 setSetting(m_invShowTotal, value, INV_SHOW_TOTAL_KEY, commit);
1970 }
1971
setInvColumnOrder(const LongVector & value,bool commit)1972 void LDPreferences::setInvColumnOrder(const LongVector &value, bool commit)
1973 {
1974 setSetting(m_invColumnOrder, value, INV_COLUMN_ORDER_KEY, commit);
1975 }
1976
1977 //void LDPreferences::setInvLastSavePath(const char *value, bool commit)
1978 //{
1979 // setSetting(m_invLastSavePath, value, INV_LAST_SAVE_PATH_KEY, commit, true);
1980 //}
1981
setDefaultZoom(TCFloat value,bool commit)1982 void LDPreferences::setDefaultZoom(TCFloat value, bool commit)
1983 {
1984 setSetting(m_defaultZoom, value, DEFAULT_ZOOM_KEY, commit);
1985 }
1986
saveDefaultView(void)1987 void LDPreferences::saveDefaultView(void)
1988 {
1989 if (m_modelViewer != NULL)
1990 {
1991 TCFloat matrix[16];
1992 TCFloat rotationMatrix[16];
1993 TCFloat otherMatrix[16] = {1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,1};
1994 char matrixString[1024];
1995 TCFloat latitude = m_modelViewer->getExamineLatitude();
1996 TCFloat longitude = m_modelViewer->getExamineLongitude();
1997
1998 memcpy(rotationMatrix, m_modelViewer->getRotationMatrix(),
1999 sizeof(rotationMatrix));
2000 TCVector::multMatrix(otherMatrix, rotationMatrix, matrix);
2001 matrix[12] = 0.0f;
2002 matrix[13] = 0.0f;
2003 matrix[14] = 0.0f;
2004 sprintf(matrixString, "%.6g,%.6g,%.6g,%.6g,%.6g,%.6g,%.6g,%.6g,%.6g",
2005 matrix[0], matrix[4], matrix[8],
2006 matrix[1], matrix[5], matrix[9],
2007 matrix[2], matrix[6], matrix[10]);
2008 TCUserDefaults::setStringForKey(matrixString, DEFAULT_MATRIX_KEY);
2009 TCUserDefaults::setFloatForKey(latitude, DEFAULT_LATITUDE_KEY);
2010 TCUserDefaults::setFloatForKey(longitude, DEFAULT_LONGITUDE_KEY);
2011 m_modelViewer->setDefaultRotationMatrix(matrix);
2012 m_modelViewer->setDefaultLatLong(latitude, longitude);
2013 }
2014 }
2015
resetDefaultView(void)2016 void LDPreferences::resetDefaultView(void)
2017 {
2018 TCUserDefaults::removeValue(DEFAULT_MATRIX_KEY);
2019 TCUserDefaults::removeValue(DEFAULT_LATITUDE_KEY);
2020 TCUserDefaults::removeValue(DEFAULT_LONGITUDE_KEY);
2021 if (m_modelViewer != NULL)
2022 {
2023 m_modelViewer->setDefaultRotationMatrix(NULL);
2024 m_modelViewer->setDefaultLatLong(30.0f, 45.0f);
2025 }
2026 }
2027
getBackgroundColor(int & r,int & g,int & b)2028 void LDPreferences::getBackgroundColor(int &r, int &g, int &b)
2029 {
2030 getRGB(m_backgroundColor, r, g, b);
2031 }
2032
getDefaultColor(int & r,int & g,int & b)2033 void LDPreferences::getDefaultColor(int &r, int &g, int &b)
2034 {
2035 getRGB(m_defaultColor, r, g, b);
2036 }
2037
getCustomColor(int index,int & r,int & g,int & b)2038 void LDPreferences::getCustomColor(int index, int &r, int &g, int &b)
2039 {
2040 getRGB(m_customColors[index], r, g, b);
2041 }
2042
getLightDirection(void)2043 LDPreferences::LightDirection LDPreferences::getLightDirection(void)
2044 {
2045 if (m_lightVector == TCVector(-1.0f, 1.0f, 1.0f))
2046 {
2047 return UpperLeft;
2048 }
2049 else if (m_lightVector == TCVector(0.0f, 1.0f, 1.0f))
2050 {
2051 return UpperMiddle;
2052 }
2053 else if (m_lightVector == TCVector(1.0f, 1.0f, 1.0f))
2054 {
2055 return UpperRight;
2056 }
2057 else if (m_lightVector == TCVector(-1.0f, 0.0f, 1.0f))
2058 {
2059 return MiddleLeft;
2060 }
2061 else if (m_lightVector == TCVector(0.0f, 0.0f, 1.0f))
2062 {
2063 return Middle;
2064 }
2065 else if (m_lightVector == TCVector(1.0f, 0.0f, 1.0f))
2066 {
2067 return MiddleRight;
2068 }
2069 else if (m_lightVector == TCVector(-1.0f, -1.0f, 1.0f))
2070 {
2071 return LowerLeft;
2072 }
2073 else if (m_lightVector == TCVector(0.0f, -1.0f, 1.0f))
2074 {
2075 return LowerMiddle;
2076 }
2077 else if (m_lightVector == TCVector(1.0f, -1.0f, 1.0f))
2078 {
2079 return LowerRight;
2080 }
2081 return CustomDirection;
2082 }
2083
getSaveDirMode(SaveOp op) const2084 LDPreferences::DefaultDirMode LDPreferences::getSaveDirMode(SaveOp op) const
2085 {
2086 DirModeMap::const_iterator it = m_saveDirModes.find(op);
2087
2088 if (it != m_saveDirModes.end())
2089 {
2090 return it->second;
2091 }
2092 else
2093 {
2094 return DDMUnknown;
2095 }
2096 }
2097
getSaveDir(SaveOp op) const2098 const std::string& LDPreferences::getSaveDir(SaveOp op) const
2099 {
2100 SaveOpStringMap::const_iterator it = m_saveDirs.find(op);
2101
2102 if (it != m_saveDirs.end())
2103 {
2104 return it->second;
2105 }
2106 else
2107 {
2108 return m_emptyString;
2109 }
2110 }
2111
getLastSaveDir(SaveOp op) const2112 const std::string& LDPreferences::getLastSaveDir(SaveOp op) const
2113 {
2114 SaveOpStringMap::const_iterator it = m_lastSaveDirs.find(op);
2115
2116 if (it != m_lastSaveDirs.end())
2117 {
2118 return it->second;
2119 }
2120 else
2121 {
2122 return m_emptyString;
2123 }
2124 }
2125
getDefaultSaveDir(SaveOp op,const std::string & modelFilename)2126 const std::string& LDPreferences::getDefaultSaveDir(
2127 SaveOp op,
2128 const std::string &modelFilename)
2129 {
2130 switch (getSaveDirMode(op))
2131 {
2132 case DDMLastDir:
2133 return getLastSaveDir(op);
2134 case DDMSpecificDir:
2135 return getSaveDir(op);
2136 default:
2137 {
2138 char *temp = directoryFromPath(modelFilename.c_str());
2139 m_modelDir = temp;
2140
2141 delete[] temp;
2142 return m_modelDir;
2143 }
2144 }
2145 }
2146
loadSaveDir(SaveOp op)2147 void LDPreferences::loadSaveDir(SaveOp op)
2148 {
2149 DefaultDirMode &mode = m_saveDirModes[op];
2150 std::string &dir = m_saveDirs[op];
2151 std::string &lastDir = m_lastSaveDirs[op];
2152
2153 mode = (DefaultDirMode)getIntSetting(m_saveDirModeKeys[op].c_str(), mode);
2154 dir = getStringSetting(m_saveDirKeys[op].c_str(), dir.c_str(), true);
2155 lastDir = getStringSetting(m_lastSaveDirKeys[op].c_str(), lastDir.c_str(),
2156 true);
2157 }
2158
commitSaveDir(SaveOp op)2159 void LDPreferences::commitSaveDir(SaveOp op)
2160 {
2161 setSaveDirMode(op, m_saveDirModes[op], true);
2162 setSaveDir(op, m_saveDirs[op].c_str(), true);
2163 setLastSaveDir(op, m_lastSaveDirs[op].c_str(), true);
2164 }
2165
setSaveDirDefault(SaveOp op,DefaultDirMode mode)2166 void LDPreferences::setSaveDirDefault(SaveOp op, DefaultDirMode mode)
2167 {
2168 setSaveDirMode(op, mode);
2169 setSaveDir(op, "");
2170 setLastSaveDir(op, "");
2171 }
2172