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