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/sound/soundmgr.hxx>
  32
  33 #include STL_IOSTREAM
  34
  35 #include <ATC/ATCdisplay.hxx>
  36 #include <Aircraft/aircraft.hxx>
  37 #include <Time/tmp.hxx>
  38 #include <FDM/UIUCModel/uiuc_aircraftdir.h>
  39 #ifdef FG_WEATHERCM
  40 #  include <WeatherCM/FGLocalWeatherDatabase.h>
  41 #else
  42 #  include <Environment/environment.hxx>
  43 #endif // FG_WEATHERCM
  44 #include <Objects/matlib.hxx>
  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     SoundMgr *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  * Get the texture rendering state.
 357  */
 358 static bool
 359 getTextures ()
 360 {
 361   return (material_lib.get_step() == 0);
 362 }
 363
 364
 365 /**
 366  * Set the texture rendering state.
 367  */
 368 static void
 369 setTextures (bool textures)
 370 {
 371   if (textures)
 372     material_lib.set_step(0);
 373   else
 374     material_lib.set_step(1);
 375 }
 376
 377
 378 /**
 379  * Return the magnetic variation
 380  */
 381 static double
 382 getMagVar ()
 383 {
 384   return globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
 385 }
 386
 387
 388 /**
 389  * Return the magnetic dip
 390  */
 391 static double
 392 getMagDip ()
 393 {
 394   return globals->get_mag()->get_magdip() * SGD_RADIANS_TO_DEGREES;
 395 }
 396
 397
 398 /**
 399  * Return the current heading in degrees.
 400  */
 401 static double
 402 getHeadingMag ()
 403 {
 404   return current_aircraft.fdm_state->get_Psi() * SGD_RADIANS_TO_DEGREES - getMagVar();
 405 }
 406
 407
 408 #ifdef FG_WEATHERCM
 409
 410 /**
 411  * Get the current visibility (meters).
 412  */
 413 static double
 414 getVisibility ()
 415 {
 416   return WeatherDatabase->getWeatherVisibility();
 417 }
 418
 419
 420 /**
 421  * Set the current visibility (meters).
 422  */
 423 static void
 424 setVisibility (double visibility)
 425 {
 426   WeatherDatabase->setWeatherVisibility(visibility);
 427 }
 428
 429 /**
 430  * Get the current wind north velocity (feet/second).
 431  */
 432 static double
 433 getWindNorth ()
 434 {
 435   return current_aircraft.fdm_state->get_V_north_airmass();
 436 }
 437
 438
 439 /**
 440  * Set the current wind north velocity (feet/second).
 441  */
 442 static void
 443 setWindNorth (double speed)
 444 {
 445   current_aircraft.fdm_state
 446     ->set_Velocities_Local_Airmass(speed, getWindEast(), getWindDown());
 447 }
 448
 449
 450 /**
 451  * Get the current wind east velocity (feet/second).
 452  */
 453 static double
 454 getWindEast ()
 455 {
 456   return current_aircraft.fdm_state->get_V_east_airmass();
 457 }
 458
 459
 460 /**
 461  * Set the current wind east velocity (feet/second).
 462  */
 463 static void
 464 setWindEast (double speed)
 465 {
 466   SG_LOG(SG_GENERAL, SG_INFO,, "Set wind-east to " << speed );
 467   current_aircraft.fdm_state->set_Velocities_Local_Airmass(getWindNorth(),
 468                                                            speed,
 469                                                            getWindDown());
 470 }
 471
 472
 473 /**
 474  * Get the current wind down velocity (feet/second).
 475  */
 476 static double
 477 getWindDown ()
 478 {
 479   return current_aircraft.fdm_state->get_V_down_airmass();
 480 }
 481
 482
 483 /**
 484  * Set the current wind down velocity (feet/second).
 485  */
 486 static void
 487 setWindDown (double speed)
 488 {
 489   current_aircraft.fdm_state->set_Velocities_Local_Airmass(getWindNorth(),
 490                                                            getWindEast(),
 491                                                            speed);
 492 }
 493
 494 #endif // FG_WEATHERCM
 495
 496 static long
 497 getWarp ()
 498 {
 499   return globals->get_warp();
 500 }
 501
 502 static void
 503 setWarp (long warp)
 504 {
 505   globals->set_warp(warp);
 506 }
 507
 508 static long
 509 getWarpDelta ()
 510 {
 511   return globals->get_warp_delta();
 512 }
 513
 514 static void
 515 setWarpDelta (long delta)
 516 {
 517   globals->set_warp_delta(delta);
 518 }
 519
 520 static bool
 521 getWindingCCW ()
 522 {
 523   return winding_ccw;
 524 }
 525
 526 static void
 527 setWindingCCW (bool state)
 528 {
 529   winding_ccw = state;
 530   if ( winding_ccw )
 531     glFrontFace ( GL_CCW );
 532   else
 533     glFrontFace ( GL_CW );
 534 }
 535
 536 static bool
 537 getFullScreen ()
 538 {
 539 #if defined(FX) && !defined(WIN32)
 540   return globals->get_fullscreen();
 541 #else
 542   return false;
 543 #endif
 544 }
 545
 546 static void
 547 setFullScreen (bool state)
 548 {
 549 #if defined(FX) && !defined(WIN32)
 550   globals->set_fullscreen(state);
 551 #  if defined(XMESA_FX_FULLSCREEN) && defined(XMESA_FX_WINDOW)
 552   XMesaSetFXmode( state ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW );
 553 #  endif
 554 #endif
 555 }
 556
 557 static bool
 558 getFDMDataLogging ()
 559 {
 560   return fdm_data_logging;
 561 }
 562
 563 static void
 564 setFDMDataLogging (bool state)
 565 {
 566                                 // kludge; no getter or setter available
 567   if (state != fdm_data_logging) {
 568     fgToggleFDMdataLogging();
 569     fdm_data_logging = state;
 570   }
 571 }
 572
 573 \f
 574 ////////////////////////////////////////////////////////////////////////
 575 // Tie the properties.
 576 ////////////////////////////////////////////////////////////////////////
 577
 578 void
 579 fgInitProps ()
 580 {
 581   SG_LOG(SG_GENERAL, SG_DEBUG, "start of fgInitProps()" );
 582                                 // Simulation
 583   fgTie("/sim/logging/priority", getLoggingPriority, setLoggingPriority);
 584   fgTie("/sim/logging/classes", getLoggingClasses, setLoggingClasses);
 585   fgTie("/sim/freeze/master", getFreeze, setFreeze);
 586   fgTie("/sim/aircraft-dir", getAircraftDir, setAircraftDir);
 587
 588   fgTie("/sim/time/elapsed-sec", getElapsedTime_sec);
 589   fgTie("/sim/time/gmt", getDateString, setDateString);
 590   fgSetArchivable("/sim/time/gmt");
 591   fgTie("/sim/time/gmt-string", getGMTString);
 592   fgTie("/sim/rendering/textures", getTextures, setTextures);
 593
 594                                 // Orientation
 595   fgTie("/orientation/heading-magnetic-deg", getHeadingMag);
 596
 597                                 // Environment
 598 #ifdef FG_WEATHERCM
 599   fgTie("/environment/visibility-m", getVisibility, setVisibility);
 600   fgSetArchivable("/environment/visibility-m");
 601   fgTie("/environment/wind-from-north-fps", getWindNorth, setWindNorth);
 602   fgSetArchivable("/environment/wind-from-north-fps");
 603   fgTie("/environment/wind-from-east-fps", getWindEast, setWindEast);
 604   fgSetArchivable("/environment/wind-from-east-fps");
 605   fgTie("/environment/wind-from-down-fps", getWindDown, setWindDown);
 606   fgSetArchivable("/environment/wind-from-down-fps");
 607 #endif
 608
 609   fgTie("/environment/magnetic-variation-deg", getMagVar);
 610   fgTie("/environment/magnetic-dip-deg", getMagDip);
 611
 612   fgTie("/sim/time/warp", getWarp, setWarp, false);
 613   fgTie("/sim/time/warp-delta", getWarpDelta, setWarpDelta);
 614
 615                                 // Misc. Temporary junk.
 616   fgTie("/sim/temp/winding-ccw", getWindingCCW, setWindingCCW, false);
 617   fgTie("/sim/temp/full-screen", getFullScreen, setFullScreen);
 618   fgTie("/sim/temp/fdm-data-logging", getFDMDataLogging, setFDMDataLogging);
 619
 620   SG_LOG(SG_GENERAL, SG_DEBUG, "end of fgInitProps()" );
 621 }
 622
 623
 624 void
 625 fgUpdateProps ()
 626 {
 627 }
 628
 629
 630 \f
 631 ////////////////////////////////////////////////////////////////////////
 632 // Save and restore.
 633 ////////////////////////////////////////////////////////////////////////
 634
 635
 636 /**
 637  * Save the current state of the simulator to a stream.
 638  */
 639 bool
 640 fgSaveFlight (ostream &output, bool write_all)
 641 {
 642
 643   fgSetBool("/sim/presets/onground", false);
 644   fgSetArchivable("/sim/presets/onground");
 645   fgSetBool("/sim/presets/trim", false);
 646   fgSetArchivable("/sim/presets/trim");
 647   fgSetString("/sim/presets/speed-set", "UVW");
 648   fgSetArchivable("/sim/presets/speed-set");
 649
 650   try {
 651     writeProperties(output, globals->get_props(), write_all);
 652   } catch (const sg_exception &e) {
 653     guiErrorMessage("Error saving flight: ", e);
 654     return false;
 655   }
 656   return true;
 657 }
 658
 659
 660 /**
 661  * Restore the current state of the simulator from a stream.
 662  */
 663 bool
 664 fgLoadFlight (istream &input)
 665 {
 666   SGPropertyNode props;
 667   try {
 668     readProperties(input, &props);
 669   } catch (const sg_exception &e) {
 670     guiErrorMessage("Error reading saved flight: ", e);
 671     return false;
 672   }
 673
 674   fgSetBool("/sim/presets/onground", false);
 675   fgSetBool("/sim/presets/trim", false);
 676   fgSetString("/sim/presets/speed-set", "UVW");
 677
 678   copyProperties(&props, globals->get_props());
 679   // When loading a flight, make it the
 680   // new initial state.
 681   globals->saveInitialState();
 682   return true;
 683 }
 684
 685
 686 bool
 687 fgLoadProps (const char * path, SGPropertyNode * props, bool in_fg_root)
 688 {
 689     string fullpath;
 690     if (in_fg_root) {
 691         SGPath loadpath(globals->get_fg_root());
 692         loadpath.append(path);
 693         fullpath = loadpath.str();
 694     } else {
 695         fullpath = path;
 696     }
 697
 698     try {
 699         readProperties(fullpath, props);
 700     } catch (const sg_exception &e) {
 701         guiErrorMessage("Error reading properties: ", e);
 702         return false;
 703     }
 704     return true;
 705 }
 706
 707
 708 \f
 709 ////////////////////////////////////////////////////////////////////////
 710 // Property convenience functions.
 711 ////////////////////////////////////////////////////////////////////////
 712
 713 SGPropertyNode *
 714 fgGetNode (const char * path, bool create)
 715 {
 716   return globals->get_props()->getNode(path, create);
 717 }
 718
 719 SGPropertyNode *
 720 fgGetNode (const char * path, int index, bool create)
 721 {
 722   return globals->get_props()->getNode(path, index, create);
 723 }
 724
 725 bool
 726 fgHasNode (const char * path)
 727 {
 728   return (fgGetNode(path, false) != 0);
 729 }
 730
 731 void
 732 fgAddChangeListener (SGPropertyChangeListener * listener, const char * path)
 733 {
 734   fgGetNode(path, true)->addChangeListener(listener);
 735 }
 736
 737 void
 738 fgAddChangeListener (SGPropertyChangeListener * listener,
 739                      const char * path, int index)
 740 {
 741   fgGetNode(path, index, true)->addChangeListener(listener);
 742 }
 743
 744 bool
 745 fgGetBool (const char * name, bool defaultValue)
 746 {
 747   return globals->get_props()->getBoolValue(name, defaultValue);
 748 }
 749
 750 int
 751 fgGetInt (const char * name, int defaultValue)
 752 {
 753   return globals->get_props()->getIntValue(name, defaultValue);
 754 }
 755
 756 int
 757 fgGetLong (const char * name, long defaultValue)
 758 {
 759   return globals->get_props()->getLongValue(name, defaultValue);
 760 }
 761
 762 float
 763 fgGetFloat (const char * name, float defaultValue)
 764 {
 765   return globals->get_props()->getFloatValue(name, defaultValue);
 766 }
 767
 768 double
 769 fgGetDouble (const char * name, double defaultValue)
 770 {
 771   return globals->get_props()->getDoubleValue(name, defaultValue);
 772 }
 773
 774 const char *
 775 fgGetString (const char * name, const char * defaultValue)
 776 {
 777   return globals->get_props()->getStringValue(name, defaultValue);
 778 }
 779
 780 bool
 781 fgSetBool (const char * name, bool val)
 782 {
 783   return globals->get_props()->setBoolValue(name, val);
 784 }
 785
 786 bool
 787 fgSetInt (const char * name, int val)
 788 {
 789   return globals->get_props()->setIntValue(name, val);
 790 }
 791
 792 bool
 793 fgSetLong (const char * name, long val)
 794 {
 795   return globals->get_props()->setLongValue(name, val);
 796 }
 797
 798 bool
 799 fgSetFloat (const char * name, float val)
 800 {
 801   return globals->get_props()->setFloatValue(name, val);
 802 }
 803
 804 bool
 805 fgSetDouble (const char * name, double val)
 806 {
 807   return globals->get_props()->setDoubleValue(name, val);
 808 }
 809
 810 bool
 811 fgSetString (const char * name, const char * val)
 812 {
 813   return globals->get_props()->setStringValue(name, val);
 814 }
 815
 816 void
 817 fgSetArchivable (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 archive flag for non-existant property "
 823            << name);
 824   else
 825     node->setAttribute(SGPropertyNode::ARCHIVE, state);
 826 }
 827
 828 void
 829 fgSetReadable (const char * name, bool state)
 830 {
 831   SGPropertyNode * node = globals->get_props()->getNode(name);
 832   if (node == 0)
 833     SG_LOG(SG_GENERAL, SG_ALERT,
 834            "Attempt to set read flag for non-existant property "
 835            << name);
 836   else
 837     node->setAttribute(SGPropertyNode::READ, state);
 838 }
 839
 840 void
 841 fgSetWritable (const char * name, bool state)
 842 {
 843   SGPropertyNode * node = globals->get_props()->getNode(name);
 844   if (node == 0)
 845     SG_LOG(SG_GENERAL, SG_ALERT,
 846            "Attempt to set write flag for non-existant property "
 847            << name);
 848   else
 849     node->setAttribute(SGPropertyNode::WRITE, state);
 850 }
 851
 852 void
 853 fgUntie (const char * name)
 854 {
 855   if (!globals->get_props()->untie(name))
 856     SG_LOG(SG_GENERAL, SG_WARN, "Failed to untie property " << name);
 857 }
 858
 859
 860 // end of fg_props.cxx