]> git.mxchange.org Git - flightgear.git/blob - src/Main/fg_props.cxx
f4b410a70b7b29e17c3b9dcaebe709ab47ab6d82
[flightgear.git] / src / Main / fg_props.cxx
1 // fg_props.cxx -- support for FlightGear properties.
2 //
3 // Written by David Megginson, started 2000.
4 //
5 // Copyright (C) 2000, 2001 David Megginson - david@megginson.com
6 //
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License as
9 // published by the Free Software Foundation; either version 2 of the
10 // License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 // General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 //
21 // $Id$
22
23 #ifdef HAVE_CONFIG_H
24 #  include "config.h"
25 #endif
26
27 #include <simgear/compiler.h>
28
29 #include <simgear/structure/exception.hxx>
30 #include <simgear/magvar/magvar.hxx>
31 #include <simgear/timing/sg_time.hxx>
32 #include <simgear/misc/sg_path.hxx>
33 #include <simgear/scene/material/matlib.hxx>
34 #include <simgear/sound/soundmgr_openal.hxx>
35
36 #include <iostream>
37
38 #include <Aircraft/aircraft.hxx>
39 #include <Time/tmp.hxx>
40 #include <Environment/environment.hxx>
41
42 #include <GUI/gui.h>
43
44 #include "globals.hxx"
45 #include "fg_props.hxx"
46
47 using std::istream;
48 using std::ostream;
49
50 static bool winding_ccw = true; // FIXME: temporary
51
52 static bool fdm_data_logging = false; // FIXME: temporary
53
54 static bool frozen = false;     // FIXME: temporary
55
56
57 \f
58 ////////////////////////////////////////////////////////////////////////
59 // Default property bindings (not yet handled by any module).
60 ////////////////////////////////////////////////////////////////////////
61
62 struct LogClassMapping {
63   sgDebugClass c;
64   string name;
65   LogClassMapping(sgDebugClass cc, string nname) { c = cc; name = nname; }
66 };
67
68 LogClassMapping log_class_mappings [] = {
69   LogClassMapping(SG_NONE, "none"),
70   LogClassMapping(SG_TERRAIN, "terrain"),
71   LogClassMapping(SG_ASTRO, "astro"),
72   LogClassMapping(SG_FLIGHT, "flight"),
73   LogClassMapping(SG_INPUT, "input"),
74   LogClassMapping(SG_GL, "gl"),
75   LogClassMapping(SG_VIEW, "view"),
76   LogClassMapping(SG_COCKPIT, "cockpit"),
77   LogClassMapping(SG_GENERAL, "general"),
78   LogClassMapping(SG_MATH, "math"),
79   LogClassMapping(SG_EVENT, "event"),
80   LogClassMapping(SG_AIRCRAFT, "aircraft"),
81   LogClassMapping(SG_AUTOPILOT, "autopilot"),
82   LogClassMapping(SG_IO, "io"),
83   LogClassMapping(SG_CLIPPER, "clipper"),
84   LogClassMapping(SG_NETWORK, "network"),
85   LogClassMapping(SG_INSTR, "instrumentation"),
86   LogClassMapping(SG_SYSTEMS, "systems"),
87   LogClassMapping(SG_UNDEFD, "")
88 };
89
90
91 /**
92  * Get the logging classes.
93  */
94 static const char *
95 getLoggingClasses ()
96 {
97   sgDebugClass classes = logbuf::get_log_classes();
98   static string result;
99   result = "";
100   for (int i = 0; log_class_mappings[i].c != SG_UNDEFD; i++) {
101     if ((classes&log_class_mappings[i].c) > 0) {
102       if (!result.empty())
103         result += '|';
104       result += log_class_mappings[i].name;
105     }
106   }
107   return result.c_str();
108 }
109
110
111 static void
112 addLoggingClass (const string &name)
113 {
114   sgDebugClass classes = logbuf::get_log_classes();
115   for (int i = 0; log_class_mappings[i].c != SG_UNDEFD; i++) {
116     if (name == log_class_mappings[i].name) {
117       logbuf::set_log_classes(sgDebugClass(classes|log_class_mappings[i].c));
118       return;
119     }
120   }
121   SG_LOG(SG_GENERAL, SG_WARN, "Unknown logging class: " << name);
122 }
123
124
125 /**
126  * Set the logging classes.
127  */
128 static void
129 setLoggingClasses (const char * c)
130 {
131   string classes = c;
132   logbuf::set_log_classes(SG_NONE);
133
134   if (classes == "none") {
135     SG_LOG(SG_GENERAL, SG_INFO, "Disabled all logging classes");
136     return;
137   }
138
139   if (classes.empty() || classes == "all") { // default
140     logbuf::set_log_classes(SG_ALL);
141     SG_LOG(SG_GENERAL, SG_INFO, "Enabled all logging classes: "
142            << getLoggingClasses());
143     return;
144   }
145
146   string rest = classes;
147   string name = "";
148   int sep = rest.find('|');
149   while (sep > 0) {
150     name = rest.substr(0, sep);
151     rest = rest.substr(sep+1);
152     addLoggingClass(name);
153     sep = rest.find('|');
154   }
155   addLoggingClass(rest);
156   SG_LOG(SG_GENERAL, SG_INFO, "Set logging classes to "
157          << getLoggingClasses());
158 }
159
160
161 /**
162  * Get the logging priority.
163  */
164 static const char *
165 getLoggingPriority ()
166 {
167   switch (logbuf::get_log_priority()) {
168   case SG_BULK:
169     return "bulk";
170   case SG_DEBUG:
171     return "debug";
172   case SG_INFO:
173     return "info";
174   case SG_WARN:
175     return "warn";
176   case SG_ALERT:
177     return "alert";
178   default:
179     SG_LOG(SG_GENERAL, SG_WARN, "Internal: Unknown logging priority number: "
180            << logbuf::get_log_priority());
181     return "unknown";
182   }
183 }
184
185
186 /**
187  * Set the logging priority.
188  */
189 static void
190 setLoggingPriority (const char * p)
191 {
192   if (p == 0)
193       return;
194   string priority = p;
195   if (priority == "bulk") {
196     logbuf::set_log_priority(SG_BULK);
197   } else if (priority == "debug") {
198     logbuf::set_log_priority(SG_DEBUG);
199   } else if (priority.empty() || priority == "info") { // default
200     logbuf::set_log_priority(SG_INFO);
201   } else if (priority == "warn") {
202     logbuf::set_log_priority(SG_WARN);
203   } else if (priority == "alert") {
204     logbuf::set_log_priority(SG_ALERT);
205   } else {
206     SG_LOG(SG_GENERAL, SG_WARN, "Unknown logging priority " << priority);
207   }
208   SG_LOG(SG_GENERAL, SG_DEBUG, "Logging priority is " << getLoggingPriority());
209 }
210
211
212 /**
213  * Return the current frozen state.
214  */
215 static bool
216 getFreeze ()
217 {
218   return frozen;
219 }
220
221
222 /**
223  * Set the current frozen state.
224  */
225 static void
226 setFreeze (bool f)
227 {
228     frozen = f;
229
230     // Stop sound on a pause
231     SGSoundMgr *s = globals->get_soundmgr();
232     if ( s != NULL ) {
233         if ( f ) {
234             s->pause();
235         } else if (!fgGetBool("/sim/sound/pause")) {
236             s->resume();
237         }
238     }
239 }
240
241
242 /**
243  * Return the number of milliseconds elapsed since simulation started.
244  */
245 static double
246 getElapsedTime_sec ()
247 {
248   return globals->get_sim_time_sec();
249 }
250
251
252 /**
253  * Return the current Zulu time.
254  */
255 static const char *
256 getDateString ()
257 {
258   static char buf[64];          // FIXME
259   struct tm * t = globals->get_time_params()->getGmt();
260   sprintf(buf, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d",
261           t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
262           t->tm_hour, t->tm_min, t->tm_sec);
263   return buf;
264 }
265
266
267 /**
268  * Set the current Zulu time.
269  */
270 static void
271 setDateString (const char * date_string)
272 {
273   static const SGPropertyNode *cur_time_override
274         = fgGetNode("/sim/time/cur-time-override", true);
275
276   SGTime * st = globals->get_time_params();
277   struct tm * current_time = st->getGmt();
278   struct tm new_time;
279
280                                 // Scan for basic ISO format
281                                 // YYYY-MM-DDTHH:MM:SS
282   int ret = sscanf(date_string, "%d-%d-%dT%d:%d:%d",
283                    &(new_time.tm_year), &(new_time.tm_mon),
284                    &(new_time.tm_mday), &(new_time.tm_hour),
285                    &(new_time.tm_min), &(new_time.tm_sec));
286
287                                 // Be pretty picky about this, so
288                                 // that strange things don't happen
289                                 // if the save file has been edited
290                                 // by hand.
291   if (ret != 6) {
292     SG_LOG(SG_INPUT, SG_WARN, "Date/time string " << date_string
293            << " not in YYYY-MM-DDTHH:MM:SS format; skipped");
294     return;
295   }
296
297                                 // OK, it looks like we got six
298                                 // values, one way or another.
299   new_time.tm_year -= 1900;
300   new_time.tm_mon -= 1;
301
302                                 // Now, tell flight gear to use
303                                 // the new time.  This was far
304                                 // too difficult, by the way.
305   long int warp =
306     mktime(&new_time) - mktime(current_time) + globals->get_warp();
307   double lon = current_aircraft.fdm_state->get_Longitude();
308   double lat = current_aircraft.fdm_state->get_Latitude();
309   globals->set_warp(warp);
310   st->update(lon, lat, cur_time_override->getLongValue(), warp);
311 }
312
313 /**
314  * Return the GMT as a string.
315  */
316 static const char *
317 getGMTString ()
318 {
319   static char buf[16];
320   struct tm *t = globals->get_time_params()->getGmt();
321   snprintf(buf, 16, "%.2d:%.2d:%.2d",
322       t->tm_hour, t->tm_min, t->tm_sec);
323   return buf;
324 }
325
326 /**
327  * Return the magnetic variation
328  */
329 static double
330 getMagVar ()
331 {
332   return globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
333 }
334
335
336 /**
337  * Return the magnetic dip
338  */
339 static double
340 getMagDip ()
341 {
342   return globals->get_mag()->get_magdip() * SGD_RADIANS_TO_DEGREES;
343 }
344
345
346 /**
347  * Return the current heading in degrees.
348  */
349 static double
350 getHeadingMag ()
351 {
352   double magheading;
353   magheading = current_aircraft.fdm_state->get_Psi() * SGD_RADIANS_TO_DEGREES - getMagVar();
354   if (magheading < 0) magheading += 360;
355   return magheading;
356 }
357
358 static long
359 getWarp ()
360 {
361   return globals->get_warp();
362 }
363
364 static void
365 setWarp (long warp)
366 {
367   globals->set_warp(warp);
368 }
369
370 static long
371 getWarpDelta ()
372 {
373   return globals->get_warp_delta();
374 }
375
376 static void
377 setWarpDelta (long delta)
378 {
379   globals->set_warp_delta(delta);
380 }
381
382 static bool
383 getWindingCCW ()
384 {
385   return winding_ccw;
386 }
387
388 static void
389 setWindingCCW (bool state)
390 {
391   winding_ccw = state;
392   if ( winding_ccw )
393     glFrontFace ( GL_CCW );
394   else
395     glFrontFace ( GL_CW );
396 }
397
398 static bool
399 getFDMDataLogging ()
400 {
401   return fdm_data_logging;
402 }
403
404 static void
405 setFDMDataLogging (bool state)
406 {
407                                 // kludge; no getter or setter available
408   if (state != fdm_data_logging) {
409     fgToggleFDMdataLogging();
410     fdm_data_logging = state;
411   }
412 }
413
414 static const char *
415 getLongitudeString ()
416 {
417   static SGConstPropertyNode_ptr n = fgGetNode("/position/longitude-deg", true);
418   static SGConstPropertyNode_ptr f = fgGetNode("/sim/lon-lat-format", true);
419   static char buf[32];
420   double d = n->getDoubleValue();
421   int format = f->getIntValue();
422   char c = d < 0.0 ? 'W' : 'E';
423
424   if (format == 0) {
425     snprintf(buf, 32, "%3.6f%c", d, c);
426
427   } else if (format == 1) {
428     // dd mm.mmm' (DMM-Format) -- uses a round-off factor tailored to the
429     // required precision of the minutes field (three decimal places),
430     // preventing minute values of 60.
431     double deg = fabs(d) + 5.0E-4 / 60.0;
432     double min = fabs(deg - int(deg)) * 60.0 - 4.999E-4;
433     snprintf(buf, 32, "%d*%06.3f%c", int(d < 0.0 ? -deg : deg), min, c);
434
435   } else {
436     // mm'ss.s'' (DMS-Format) -- uses a round-off factor tailored to the
437     // required precision of the seconds field (one decimal place),
438     // preventing second values of 60.
439     double deg = fabs(d) + 0.05 / 3600.0;
440     double min = (deg - int(deg)) * 60.0;
441     double sec = (min - int(min)) * 60.0 - 0.049;
442     snprintf(buf, 32, "%d*%02d %04.1f%c", int(d < 0.0 ? -deg : deg),
443         int(min), fabs(sec), c);
444   }
445   buf[31] = '\0';
446   return buf;
447 }
448
449 static const char *
450 getLatitudeString ()
451 {
452   static SGConstPropertyNode_ptr n = fgGetNode("/position/latitude-deg", true);
453   static SGConstPropertyNode_ptr f = fgGetNode("/sim/lon-lat-format", true);
454   static char buf[32];
455   double d = n->getDoubleValue();
456   int format = f->getIntValue();
457   char c = d < 0.0 ? 'S' : 'N';
458
459   if (format == 0) {
460     snprintf(buf, 32, "%3.6f%c", d, c);
461
462   } else if (format == 1) {
463     double deg = fabs(d) + 5.0E-4 / 60.0;
464     double min = fabs(deg - int(deg)) * 60.0 - 4.999E-4;
465     snprintf(buf, 32, "%d*%06.3f%c", int(d < 0.0 ? -deg : deg), min, c);
466
467   } else {
468     double deg = fabs(d) + 0.05 / 3600.0;
469     double min = (deg - int(deg)) * 60.0;
470     double sec = (min - int(min)) * 60.0 - 0.049;
471     snprintf(buf, 32, "%d*%02d %04.1f%c", int(d < 0.0 ? -deg : deg),
472         int(min), fabs(sec), c);
473   }
474   buf[31] = '\0';
475   return buf;
476 }
477
478
479
480 \f
481 ////////////////////////////////////////////////////////////////////////
482 // Tie the properties.
483 ////////////////////////////////////////////////////////////////////////
484
485 FGProperties::FGProperties ()
486 {
487 }
488
489 FGProperties::~FGProperties ()
490 {
491 }
492
493 void
494 FGProperties::init ()
495 {
496 }
497
498 void
499 FGProperties::bind ()
500 {
501                                 // Simulation
502   fgTie("/sim/logging/priority", getLoggingPriority, setLoggingPriority);
503   fgTie("/sim/logging/classes", getLoggingClasses, setLoggingClasses);
504   fgTie("/sim/freeze/master", getFreeze, setFreeze);
505
506   fgTie("/sim/time/elapsed-sec", getElapsedTime_sec);
507   fgTie("/sim/time/gmt", getDateString, setDateString);
508   fgSetArchivable("/sim/time/gmt");
509   fgTie("/sim/time/gmt-string", getGMTString);
510
511                                 // Position
512   fgTie("/position/latitude-string", getLatitudeString);
513   fgTie("/position/longitude-string", getLongitudeString);
514
515                                 // Orientation
516   fgTie("/orientation/heading-magnetic-deg", getHeadingMag);
517
518   fgTie("/environment/magnetic-variation-deg", getMagVar);
519   fgTie("/environment/magnetic-dip-deg", getMagDip);
520
521   fgTie("/sim/time/warp", getWarp, setWarp, false);
522   fgTie("/sim/time/warp-delta", getWarpDelta, setWarpDelta);
523
524                                 // Misc. Temporary junk.
525   fgTie("/sim/temp/winding-ccw", getWindingCCW, setWindingCCW, false);
526   fgTie("/sim/temp/fdm-data-logging", getFDMDataLogging, setFDMDataLogging);
527 }
528
529 void
530 FGProperties::unbind ()
531 {
532                                 // Simulation
533   fgUntie("/sim/logging/priority");
534   fgUntie("/sim/logging/classes");
535   fgUntie("/sim/freeze/master");
536
537   fgUntie("/sim/time/elapsed-sec");
538   fgUntie("/sim/time/gmt");
539   fgUntie("/sim/time/gmt-string");
540                                 // Position
541   fgUntie("/position/latitude-string");
542   fgUntie("/position/longitude-string");
543
544                                 // Orientation
545   fgUntie("/orientation/heading-magnetic-deg");
546
547                                 // Environment
548   fgUntie("/environment/magnetic-variation-deg");
549   fgUntie("/environment/magnetic-dip-deg");
550
551   fgUntie("/sim/time/warp");
552   fgUntie("/sim/time/warp-delta");
553
554                                 // Misc. Temporary junk.
555   fgUntie("/sim/temp/winding-ccw");
556   fgUntie("/sim/temp/full-screen");
557   fgUntie("/sim/temp/fdm-data-logging");
558 }
559
560 void
561 FGProperties::update (double dt)
562 {
563                                 // Date and time
564     struct tm *t = globals->get_time_params()->getGmt();
565
566     fgSetInt("/sim/time/utc/year", t->tm_year + 1900);
567     fgSetInt("/sim/time/utc/month", t->tm_mon + 1);
568     fgSetInt("/sim/time/utc/day", t->tm_mday);
569     fgSetInt("/sim/time/utc/hour", t->tm_hour);
570     fgSetInt("/sim/time/utc/minute", t->tm_min);
571     fgSetInt("/sim/time/utc/second", t->tm_sec);
572
573     fgSetDouble("/sim/time/utc/day-seconds",
574                 t->tm_hour * 3600 +
575                 t->tm_min * 60 +
576                 t->tm_sec);
577
578     fgSetInt("/sim/time/local-offset",
579              globals->get_time_params()->get_local_offset());
580 }
581
582
583 \f
584 ////////////////////////////////////////////////////////////////////////
585 // Save and restore.
586 ////////////////////////////////////////////////////////////////////////
587
588
589 /**
590  * Save the current state of the simulator to a stream.
591  */
592 bool
593 fgSaveFlight (ostream &output, bool write_all)
594 {
595
596   fgSetBool("/sim/presets/onground", false);
597   fgSetArchivable("/sim/presets/onground");
598   fgSetBool("/sim/presets/trim", false);
599   fgSetArchivable("/sim/presets/trim");
600   fgSetString("/sim/presets/speed-set", "UVW");
601   fgSetArchivable("/sim/presets/speed-set");
602
603   try {
604     writeProperties(output, globals->get_props(), write_all);
605   } catch (const sg_exception &e) {
606     guiErrorMessage("Error saving flight: ", e);
607     return false;
608   }
609   return true;
610 }
611
612
613 /**
614  * Restore the current state of the simulator from a stream.
615  */
616 bool
617 fgLoadFlight (istream &input)
618 {
619   SGPropertyNode props;
620   try {
621     readProperties(input, &props);
622   } catch (const sg_exception &e) {
623     guiErrorMessage("Error reading saved flight: ", e);
624     return false;
625   }
626
627   fgSetBool("/sim/presets/onground", false);
628   fgSetBool("/sim/presets/trim", false);
629   fgSetString("/sim/presets/speed-set", "UVW");
630
631   copyProperties(&props, globals->get_props());
632   // When loading a flight, make it the
633   // new initial state.
634   globals->saveInitialState();
635   return true;
636 }
637
638
639 bool
640 fgLoadProps (const char * path, SGPropertyNode * props, bool in_fg_root, int default_mode)
641 {
642     string fullpath;
643     if (in_fg_root) {
644         SGPath loadpath(globals->get_fg_root());
645         loadpath.append(path);
646         fullpath = loadpath.str();
647     } else {
648         fullpath = path;
649     }
650
651     try {
652         readProperties(fullpath, props, default_mode);
653     } catch (const sg_exception &e) {
654         guiErrorMessage("Error reading properties: ", e);
655         return false;
656     }
657     return true;
658 }
659
660
661 \f
662 ////////////////////////////////////////////////////////////////////////
663 // Property convenience functions.
664 ////////////////////////////////////////////////////////////////////////
665
666 SGPropertyNode *
667 fgGetNode (const char * path, bool create)
668 {
669   return globals->get_props()->getNode(path, create);
670 }
671
672 SGPropertyNode * 
673 fgGetNode (const char * path, int index, bool create)
674 {
675   return globals->get_props()->getNode(path, index, create);
676 }
677
678 bool
679 fgHasNode (const char * path)
680 {
681   return (fgGetNode(path, false) != 0);
682 }
683
684 void
685 fgAddChangeListener (SGPropertyChangeListener * listener, const char * path)
686 {
687   fgGetNode(path, true)->addChangeListener(listener);
688 }
689
690 void
691 fgAddChangeListener (SGPropertyChangeListener * listener,
692                      const char * path, int index)
693 {
694   fgGetNode(path, index, true)->addChangeListener(listener);
695 }
696
697 bool
698 fgGetBool (const char * name, bool defaultValue)
699 {
700   return globals->get_props()->getBoolValue(name, defaultValue);
701 }
702
703 int
704 fgGetInt (const char * name, int defaultValue)
705 {
706   return globals->get_props()->getIntValue(name, defaultValue);
707 }
708
709 int
710 fgGetLong (const char * name, long defaultValue)
711 {
712   return globals->get_props()->getLongValue(name, defaultValue);
713 }
714
715 float
716 fgGetFloat (const char * name, float defaultValue)
717 {
718   return globals->get_props()->getFloatValue(name, defaultValue);
719 }
720
721 double
722 fgGetDouble (const char * name, double defaultValue)
723 {
724   return globals->get_props()->getDoubleValue(name, defaultValue);
725 }
726
727 const char *
728 fgGetString (const char * name, const char * defaultValue)
729 {
730   return globals->get_props()->getStringValue(name, defaultValue);
731 }
732
733 bool
734 fgSetBool (const char * name, bool val)
735 {
736   return globals->get_props()->setBoolValue(name, val);
737 }
738
739 bool
740 fgSetInt (const char * name, int val)
741 {
742   return globals->get_props()->setIntValue(name, val);
743 }
744
745 bool
746 fgSetLong (const char * name, long val)
747 {
748   return globals->get_props()->setLongValue(name, val);
749 }
750
751 bool
752 fgSetFloat (const char * name, float val)
753 {
754   return globals->get_props()->setFloatValue(name, val);
755 }
756
757 bool
758 fgSetDouble (const char * name, double val)
759 {
760   return globals->get_props()->setDoubleValue(name, val);
761 }
762
763 bool
764 fgSetString (const char * name, const char * val)
765 {
766   return globals->get_props()->setStringValue(name, val);
767 }
768
769 void
770 fgSetArchivable (const char * name, bool state)
771 {
772   SGPropertyNode * node = globals->get_props()->getNode(name);
773   if (node == 0)
774     SG_LOG(SG_GENERAL, SG_DEBUG,
775            "Attempt to set archive flag for non-existant property "
776            << name);
777   else
778     node->setAttribute(SGPropertyNode::ARCHIVE, state);
779 }
780
781 void
782 fgSetReadable (const char * name, bool state)
783 {
784   SGPropertyNode * node = globals->get_props()->getNode(name);
785   if (node == 0)
786     SG_LOG(SG_GENERAL, SG_DEBUG,
787            "Attempt to set read flag for non-existant property "
788            << name);
789   else
790     node->setAttribute(SGPropertyNode::READ, state);
791 }
792
793 void
794 fgSetWritable (const char * name, bool state)
795 {
796   SGPropertyNode * node = globals->get_props()->getNode(name);
797   if (node == 0)
798     SG_LOG(SG_GENERAL, SG_DEBUG,
799            "Attempt to set write flag for non-existant property "
800            << name);
801   else
802     node->setAttribute(SGPropertyNode::WRITE, state);
803 }
804
805 void
806 fgUntie (const char * name)
807 {
808   if (!globals->get_props()->untie(name))
809     SG_LOG(SG_GENERAL, SG_WARN, "Failed to untie property " << name);
810 }
811
812
813 // end of fg_props.cxx