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
  31 #include STL_IOSTREAM
  32
  33 #include <ATC/ATCdisplay.hxx>
  34 #include <Aircraft/aircraft.hxx>
  35 #include <Time/tmp.hxx>
  36 #include <FDM/UIUCModel/uiuc_aircraftdir.h>
  37 #ifndef FG_NEW_ENVIRONMENT
  38 #  include <WeatherCM/FGLocalWeatherDatabase.h>
  39 #else
  40 #  include <Environment/environment.hxx>
  41 #endif // FG_NEW_ENVIRONMENT
  42 #include <Objects/matlib.hxx>
  43
  44 #include <GUI/gui.h>
  45 #include <Sound/soundmgr.hxx>
  46
  47 #include "globals.hxx"
  48 #include "fgfs.hxx"
  49 #include "fg_props.hxx"
  50
  51 #if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
  52 SG_USING_STD(istream);
  53 SG_USING_STD(ostream);
  54 #endif
  55
  56 #if !defined(FG_NEW_ENVIRONMENT)
  57 static double getWindNorth ();
  58 static double getWindEast ();
  59 static double getWindDown ();
  60 #endif // FG_NEW_ENVIRONMENT
  61
  62 static bool winding_ccw = true; // FIXME: temporary
  63
  64 static bool fdm_data_logging = false; // FIXME: temporary
  65
  66 static bool frozen = false;     // FIXME: temporary
  67
  68
  69 \f
  70 ////////////////////////////////////////////////////////////////////////
  71 // Default property bindings (not yet handled by any module).
  72 ////////////////////////////////////////////////////////////////////////
  73
  74 struct LogClassMapping {
  75   sgDebugClass c;
  76   string name;
  77   LogClassMapping(sgDebugClass cc, string nname) { c = cc; name = nname; }
  78 };
  79
  80 LogClassMapping log_class_mappings [] = {
  81   LogClassMapping(SG_NONE, "none"),
  82   LogClassMapping(SG_TERRAIN, "terrain"),
  83   LogClassMapping(SG_ASTRO, "astro"),
  84   LogClassMapping(SG_FLIGHT, "flight"),
  85   LogClassMapping(SG_INPUT, "input"),
  86   LogClassMapping(SG_GL, "gl"),
  87   LogClassMapping(SG_VIEW, "view"),
  88   LogClassMapping(SG_COCKPIT, "cockpit"),
  89   LogClassMapping(SG_GENERAL, "general"),
  90   LogClassMapping(SG_MATH, "math"),
  91   LogClassMapping(SG_EVENT, "event"),
  92   LogClassMapping(SG_AIRCRAFT, "aircraft"),
  93   LogClassMapping(SG_AUTOPILOT, "autopilot"),
  94   LogClassMapping(SG_IO, "io"),
  95   LogClassMapping(SG_CLIPPER, "clipper"),
  96   LogClassMapping(SG_NETWORK, "network"),
  97   LogClassMapping(SG_UNDEFD, "")
  98 };
  99
 100
 101 /**
 102  * Get the logging classes.
 103  */
 104 static const char *
 105 getLoggingClasses ()
 106 {
 107   sgDebugClass classes = logbuf::get_log_classes();
 108   static string result = "";    // FIXME
 109   for (int i = 0; log_class_mappings[i].c != SG_UNDEFD; i++) {
 110     if ((classes&log_class_mappings[i].c) > 0) {
 111       if (!result.empty())
 112         result += '|';
 113       result += log_class_mappings[i].name;
 114     }
 115   }
 116   return result.c_str();
 117 }
 118
 119
 120 static void
 121 addLoggingClass (const string &name)
 122 {
 123   sgDebugClass classes = logbuf::get_log_classes();
 124   for (int i = 0; log_class_mappings[i].c != SG_UNDEFD; i++) {
 125     if (name == log_class_mappings[i].name) {
 126       logbuf::set_log_classes(sgDebugClass(classes|log_class_mappings[i].c));
 127       return;
 128     }
 129   }
 130   SG_LOG(SG_GENERAL, SG_ALERT, "Unknown logging class: " << name);
 131 }
 132
 133
 134 /**
 135  * Set the logging classes.
 136  */
 137 static void
 138 setLoggingClasses (const char * c)
 139 {
 140   string classes = c;
 141   logbuf::set_log_classes(SG_NONE);
 142
 143   if (classes == "none") {
 144     SG_LOG(SG_GENERAL, SG_INFO, "Disabled all logging classes");
 145     return;
 146   }
 147
 148   if (classes.empty() || classes == "all") { // default
 149     logbuf::set_log_classes(SG_ALL);
 150     SG_LOG(SG_GENERAL, SG_INFO, "Enabled all logging classes: "
 151            << getLoggingClasses());
 152     return;
 153   }
 154
 155   string rest = classes;
 156   string name = "";
 157   int sep = rest.find('|');
 158   while (sep > 0) {
 159     name = rest.substr(0, sep);
 160     rest = rest.substr(sep+1);
 161     addLoggingClass(name);
 162     sep = rest.find('|');
 163   }
 164   addLoggingClass(rest);
 165   SG_LOG(SG_GENERAL, SG_INFO, "Set logging classes to "
 166          << getLoggingClasses());
 167 }
 168
 169
 170 /**
 171  * Get the logging priority.
 172  */
 173 static const char *
 174 getLoggingPriority ()
 175 {
 176   switch (logbuf::get_log_priority()) {
 177   case SG_BULK:
 178     return "bulk";
 179   case SG_DEBUG:
 180     return "debug";
 181   case SG_INFO:
 182     return "info";
 183   case SG_WARN:
 184     return "warn";
 185   case SG_ALERT:
 186     return "alert";
 187   default:
 188     SG_LOG(SG_GENERAL, SG_WARN, "Internal: Unknown logging priority number: "
 189            << logbuf::get_log_priority());
 190     return "unknown";
 191   }
 192 }
 193
 194
 195 /**
 196  * Set the logging priority.
 197  */
 198 static void
 199 setLoggingPriority (const char * p)
 200 {
 201   string priority = p;
 202   if (priority == "bulk") {
 203     logbuf::set_log_priority(SG_BULK);
 204   } else if (priority == "debug") {
 205     logbuf::set_log_priority(SG_DEBUG);
 206   } else if (priority.empty() || priority == "info") { // default
 207     logbuf::set_log_priority(SG_INFO);
 208   } else if (priority == "warn") {
 209     logbuf::set_log_priority(SG_WARN);
 210   } else if (priority == "alert") {
 211     logbuf::set_log_priority(SG_ALERT);
 212   } else {
 213     SG_LOG(SG_GENERAL, SG_WARN, "Unknown logging priority " << priority);
 214   }
 215   SG_LOG(SG_GENERAL, SG_INFO, "Logging priority is " << getLoggingPriority());
 216 }
 217
 218
 219 /**
 220  * Return the current frozen state.
 221  */
 222 static bool
 223 getFreeze ()
 224 {
 225   return frozen;
 226 }
 227
 228
 229 /**
 230  * Set the current frozen state.
 231  */
 232 static void
 233 setFreeze (bool f)
 234 {
 235   frozen = f;
 236                                 // Stop sound on a pause
 237   if (f)
 238     globals->get_soundmgr()->pause();
 239   else
 240     globals->get_soundmgr()->resume();
 241 }
 242
 243
 244 /**
 245  * Return the current aircraft directory (UIUC) as a string.
 246  */
 247 static const char *
 248 getAircraftDir ()
 249 {
 250   return aircraft_dir.c_str();
 251 }
 252
 253
 254 /**
 255  * Set the current aircraft directory (UIUC).
 256  */
 257 static void
 258 setAircraftDir (const char * dir)
 259 {
 260   aircraft_dir = dir;
 261 }
 262
 263
 264 /**
 265  * Return the number of milliseconds elapsed since simulation started.
 266  */
 267 static double
 268 getElapsedTime_ms ()
 269 {
 270   return globals->get_sim_time_ms();
 271 }
 272
 273
 274 /**
 275  * Return the current Zulu time.
 276  */
 277 static const char *
 278 getDateString ()
 279 {
 280   static char buf[64];          // FIXME
 281   struct tm * t = globals->get_time_params()->getGmt();
 282   sprintf(buf, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d",
 283           t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
 284           t->tm_hour, t->tm_min, t->tm_sec);
 285   return buf;
 286 }
 287
 288
 289 /**
 290  * Set the current Zulu time.
 291  */
 292 static void
 293 setDateString (const char * date_string)
 294 {
 295   static const SGPropertyNode *cur_time_override
 296         = fgGetNode("/sim/time/cur-time-override", true);
 297
 298   SGTime * st = globals->get_time_params();
 299   struct tm * current_time = st->getGmt();
 300   struct tm new_time;
 301
 302                                 // Scan for basic ISO format
 303                                 // YYYY-MM-DDTHH:MM:SS
 304   int ret = sscanf(date_string, "%d-%d-%dT%d:%d:%d",
 305                    &(new_time.tm_year), &(new_time.tm_mon),
 306                    &(new_time.tm_mday), &(new_time.tm_hour),
 307                    &(new_time.tm_min), &(new_time.tm_sec));
 308
 309                                 // Be pretty picky about this, so
 310                                 // that strange things don't happen
 311                                 // if the save file has been edited
 312                                 // by hand.
 313   if (ret != 6) {
 314     SG_LOG(SG_INPUT, SG_ALERT, "Date/time string " << date_string
 315            << " not in YYYY-MM-DDTHH:MM:SS format; skipped");
 316     return;
 317   }
 318
 319                                 // OK, it looks like we got six
 320                                 // values, one way or another.
 321   new_time.tm_year -= 1900;
 322   new_time.tm_mon -= 1;
 323
 324                                 // Now, tell flight gear to use
 325                                 // the new time.  This was far
 326                                 // too difficult, by the way.
 327   long int warp =
 328     mktime(&new_time) - mktime(current_time) + globals->get_warp();
 329   double lon = current_aircraft.fdm_state->get_Longitude();
 330   double lat = current_aircraft.fdm_state->get_Latitude();
 331   globals->set_warp(warp);
 332   st->update(lon, lat, cur_time_override->getLongValue(), warp);
 333   fgUpdateSkyAndLightingParams();
 334 }
 335
 336 /**
 337  * Return the GMT as a string.
 338  */
 339 static const char *
 340 getGMTString ()
 341 {
 342   static char buf[16];          // FIXME
 343   struct tm *t = globals->get_time_params()->getGmt();
 344   sprintf(buf, " %.2d:%.2d:%.2d",
 345           t->tm_hour, t->tm_min, t->tm_sec);
 346   // cout << t << " " << buf << endl;
 347   return buf;
 348 }
 349
 350
 351 /**
 352  * Get the texture rendering state.
 353  */
 354 static bool
 355 getTextures ()
 356 {
 357   return (material_lib.get_step() == 0);
 358 }
 359
 360
 361 /**
 362  * Set the texture rendering state.
 363  */
 364 static void
 365 setTextures (bool textures)
 366 {
 367   if (textures)
 368     material_lib.set_step(0);
 369   else
 370     material_lib.set_step(1);
 371 }
 372
 373
 374 /**
 375  * Return the magnetic variation
 376  */
 377 static double
 378 getMagVar ()
 379 {
 380   return globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
 381 }
 382
 383
 384 /**
 385  * Return the magnetic dip
 386  */
 387 static double
 388 getMagDip ()
 389 {
 390   return globals->get_mag()->get_magdip() * SGD_RADIANS_TO_DEGREES;
 391 }
 392
 393
 394 /**
 395  * Return the current heading in degrees.
 396  */
 397 static double
 398 getHeadingMag ()
 399 {
 400   return current_aircraft.fdm_state->get_Psi() * SGD_RADIANS_TO_DEGREES - getMagVar();
 401 }
 402
 403
 404 #if !defined(FG_NEW_ENVIRONMENT)
 405
 406 /**
 407  * Get the current visibility (meters).
 408  */
 409 static double
 410 getVisibility ()
 411 {
 412   return WeatherDatabase->getWeatherVisibility();
 413 }
 414
 415
 416 /**
 417  * Set the current visibility (meters).
 418  */
 419 static void
 420 setVisibility (double visibility)
 421 {
 422   WeatherDatabase->setWeatherVisibility(visibility);
 423 }
 424
 425 /**
 426  * Get the current wind north velocity (feet/second).
 427  */
 428 static double
 429 getWindNorth ()
 430 {
 431   return current_aircraft.fdm_state->get_V_north_airmass();
 432 }
 433
 434
 435 /**
 436  * Set the current wind north velocity (feet/second).
 437  */
 438 static void
 439 setWindNorth (double speed)
 440 {
 441   current_aircraft.fdm_state
 442     ->set_Velocities_Local_Airmass(speed, getWindEast(), getWindDown());
 443 }
 444
 445
 446 /**
 447  * Get the current wind east velocity (feet/second).
 448  */
 449 static double
 450 getWindEast ()
 451 {
 452   return current_aircraft.fdm_state->get_V_east_airmass();
 453 }
 454
 455
 456 /**
 457  * Set the current wind east velocity (feet/second).
 458  */
 459 static void
 460 setWindEast (double speed)
 461 {
 462   cout << "Set wind-east to " << speed << endl;
 463   current_aircraft.fdm_state->set_Velocities_Local_Airmass(getWindNorth(),
 464                                                            speed,
 465                                                            getWindDown());
 466 }
 467
 468
 469 /**
 470  * Get the current wind down velocity (feet/second).
 471  */
 472 static double
 473 getWindDown ()
 474 {
 475   return current_aircraft.fdm_state->get_V_down_airmass();
 476 }
 477
 478
 479 /**
 480  * Set the current wind down velocity (feet/second).
 481  */
 482 static void
 483 setWindDown (double speed)
 484 {
 485   current_aircraft.fdm_state->set_Velocities_Local_Airmass(getWindNorth(),
 486                                                            getWindEast(),
 487                                                            speed);
 488 }
 489
 490 #endif // FG_NEW_ENVIRONMENT
 491
 492 static long
 493 getWarp ()
 494 {
 495   return globals->get_warp();
 496 }
 497
 498 static void
 499 setWarp (long warp)
 500 {
 501   globals->set_warp(warp);
 502 }
 503
 504 static long
 505 getWarpDelta ()
 506 {
 507   return globals->get_warp_delta();
 508 }
 509
 510 static void
 511 setWarpDelta (long delta)
 512 {
 513   globals->set_warp_delta(delta);
 514 }
 515
 516 static bool
 517 getWindingCCW ()
 518 {
 519   return winding_ccw;
 520 }
 521
 522 static void
 523 setWindingCCW (bool state)
 524 {
 525   winding_ccw = state;
 526   if ( winding_ccw )
 527     glFrontFace ( GL_CCW );
 528   else
 529     glFrontFace ( GL_CW );
 530 }
 531
 532 static bool
 533 getFullScreen ()
 534 {
 535 #if defined(FX) && !defined(WIN32)
 536   return globals->get_fullscreen();
 537 #else
 538   return false;
 539 #endif
 540 }
 541
 542 static void
 543 setFullScreen (bool state)
 544 {
 545 #if defined(FX) && !defined(WIN32)
 546   globals->set_fullscreen(state);
 547 #  if defined(XMESA_FX_FULLSCREEN) && defined(XMESA_FX_WINDOW)
 548   XMesaSetFXmode( state ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW );
 549 #  endif
 550 #endif
 551 }
 552
 553 static bool
 554 getFDMDataLogging ()
 555 {
 556   return fdm_data_logging;
 557 }
 558
 559 static void
 560 setFDMDataLogging (bool state)
 561 {
 562                                 // kludge; no getter or setter available
 563   if (state != fdm_data_logging) {
 564     fgToggleFDMdataLogging();
 565     fdm_data_logging = state;
 566   }
 567 }
 568
 569 \f
 570 ////////////////////////////////////////////////////////////////////////
 571 // Tie the properties.
 572 ////////////////////////////////////////////////////////////////////////
 573
 574 void
 575 fgInitProps ()
 576 {
 577                                 // Simulation
 578   fgTie("/sim/logging/priority", getLoggingPriority, setLoggingPriority);
 579   fgTie("/sim/logging/classes", getLoggingClasses, setLoggingClasses);
 580   fgTie("/sim/freeze/master", getFreeze, setFreeze);
 581   fgTie("/sim/aircraft-dir", getAircraftDir, setAircraftDir);
 582
 583   fgTie("/sim/time/elapsed-ms", getElapsedTime_ms);
 584   fgTie("/sim/time/gmt", getDateString, setDateString);
 585   fgSetArchivable("/sim/time/gmt");
 586   fgTie("/sim/time/gmt-string", getGMTString);
 587   fgTie("/sim/rendering/textures", getTextures, setTextures);
 588
 589                                 // Orientation
 590   fgTie("/orientation/heading-magnetic-deg", getHeadingMag);
 591
 592                                 // Environment
 593 #if !defined(FG_NEW_ENVIRONMENT)
 594   fgTie("/environment/visibility-m", getVisibility, setVisibility);
 595   fgSetArchivable("/environment/visibility-m");
 596   fgTie("/environment/wind-from-north-fps", getWindNorth, setWindNorth);
 597   fgSetArchivable("/environment/wind-from-north-fps");
 598   fgTie("/environment/wind-from-east-fps", getWindEast, setWindEast);
 599   fgSetArchivable("/environment/wind-from-east-fps");
 600   fgTie("/environment/wind-from-down-fps", getWindDown, setWindDown);
 601   fgSetArchivable("/environment/wind-from-down-fps");
 602 #endif
 603
 604   fgTie("/environment/magnetic-variation-deg", getMagVar);
 605   fgTie("/environment/magnetic-dip-deg", getMagDip);
 606
 607   fgTie("/sim/time/warp", getWarp, setWarp, false);
 608   fgTie("/sim/time/warp-delta", getWarpDelta, setWarpDelta);
 609
 610                                 // Misc. Temporary junk.
 611   fgTie("/sim/temp/winding-ccw", getWindingCCW, setWindingCCW, false);
 612   fgTie("/sim/temp/full-screen", getFullScreen, setFullScreen);
 613   fgTie("/sim/temp/fdm-data-logging", getFDMDataLogging, setFDMDataLogging);
 614
 615 }
 616
 617
 618 void
 619 fgUpdateProps ()
 620 {
 621 }
 622
 623
 624 \f
 625 ////////////////////////////////////////////////////////////////////////
 626 // Save and restore.
 627 ////////////////////////////////////////////////////////////////////////
 628
 629
 630 /**
 631  * Save the current state of the simulator to a stream.
 632  */
 633 bool
 634 fgSaveFlight (ostream &output, bool write_all)
 635 {
 636
 637   fgSetBool("/sim/startup/onground", false);
 638   fgSetArchivable("/sim/startup/onground");
 639   fgSetBool("/sim/startup/trim", false);
 640   fgSetArchivable("/sim/startup/trim");
 641   fgSetString("/sim/startup/speed-set", "UVW");
 642   fgSetArchivable("/sim/startup/speed-set");
 643
 644   try {
 645     writeProperties(output, globals->get_props(), write_all);
 646   } catch (const sg_exception &e) {
 647     guiErrorMessage("Error saving flight: ", e);
 648     return false;
 649   }
 650   return true;
 651 }
 652
 653
 654 /**
 655  * Restore the current state of the simulator from a stream.
 656  */
 657 bool
 658 fgLoadFlight (istream &input)
 659 {
 660   SGPropertyNode props;
 661   try {
 662     readProperties(input, &props);
 663   } catch (const sg_exception &e) {
 664     guiErrorMessage("Error reading saved flight: ", e);
 665     return false;
 666   }
 667
 668   fgSetBool("/sim/startup/onground", false);
 669   fgSetBool("/sim/startup/trim", false);
 670   fgSetString("/sim/startup/speed-set", "UVW");
 671
 672   copyProperties(&props, globals->get_props());
 673   // When loading a flight, make it the
 674   // new initial state.
 675   globals->saveInitialState();
 676   return true;
 677 }
 678
 679
 680 \f
 681 ////////////////////////////////////////////////////////////////////////
 682 // Property convenience functions.
 683 ////////////////////////////////////////////////////////////////////////
 684
 685 SGPropertyNode *
 686 fgGetNode (const char * path, bool create)
 687 {
 688   return globals->get_props()->getNode(path, create);
 689 }
 690
 691 SGPropertyNode *
 692 fgGetNode (const char * path, int index, bool create)
 693 {
 694   return globals->get_props()->getNode(path, index, create);
 695 }
 696
 697 bool
 698 fgHasNode (const char * path)
 699 {
 700   return (fgGetNode(path, false) != 0);
 701 }
 702
 703 bool
 704 fgGetBool (const char * name, bool defaultValue)
 705 {
 706   return globals->get_props()->getBoolValue(name, defaultValue);
 707 }
 708
 709 int
 710 fgGetInt (const char * name, int defaultValue)
 711 {
 712   return globals->get_props()->getIntValue(name, defaultValue);
 713 }
 714
 715 int
 716 fgGetLong (const char * name, long defaultValue)
 717 {
 718   return globals->get_props()->getLongValue(name, defaultValue);
 719 }
 720
 721 float
 722 fgGetFloat (const char * name, float defaultValue)
 723 {
 724   return globals->get_props()->getFloatValue(name, defaultValue);
 725 }
 726
 727 double
 728 fgGetDouble (const char * name, double defaultValue)
 729 {
 730   return globals->get_props()->getDoubleValue(name, defaultValue);
 731 }
 732
 733 const char *
 734 fgGetString (const char * name, const char * defaultValue)
 735 {
 736   return globals->get_props()->getStringValue(name, defaultValue);
 737 }
 738
 739 bool
 740 fgSetBool (const char * name, bool val)
 741 {
 742   return globals->get_props()->setBoolValue(name, val);
 743 }
 744
 745 bool
 746 fgSetInt (const char * name, int val)
 747 {
 748   return globals->get_props()->setIntValue(name, val);
 749 }
 750
 751 bool
 752 fgSetLong (const char * name, long val)
 753 {
 754   return globals->get_props()->setLongValue(name, val);
 755 }
 756
 757 bool
 758 fgSetFloat (const char * name, float val)
 759 {
 760   return globals->get_props()->setFloatValue(name, val);
 761 }
 762
 763 bool
 764 fgSetDouble (const char * name, double val)
 765 {
 766   return globals->get_props()->setDoubleValue(name, val);
 767 }
 768
 769 bool
 770 fgSetString (const char * name, const char * val)
 771 {
 772   return globals->get_props()->setStringValue(name, val);
 773 }
 774
 775 void
 776 fgSetArchivable (const char * name, bool state)
 777 {
 778   SGPropertyNode * node = globals->get_props()->getNode(name);
 779   if (node == 0)
 780     SG_LOG(SG_GENERAL, SG_ALERT,
 781            "Attempt to set archive flag for non-existant property "
 782            << name);
 783   else
 784     node->setAttribute(SGPropertyNode::ARCHIVE, state);
 785 }
 786
 787 void
 788 fgSetReadable (const char * name, bool state)
 789 {
 790   SGPropertyNode * node = globals->get_props()->getNode(name);
 791   if (node == 0)
 792     SG_LOG(SG_GENERAL, SG_ALERT,
 793            "Attempt to set read flag for non-existant property "
 794            << name);
 795   else
 796     node->setAttribute(SGPropertyNode::READ, state);
 797 }
 798
 799 void
 800 fgSetWritable (const char * name, bool state)
 801 {
 802   SGPropertyNode * node = globals->get_props()->getNode(name);
 803   if (node == 0)
 804     SG_LOG(SG_GENERAL, SG_ALERT,
 805            "Attempt to set write flag for non-existant property "
 806            << name);
 807   else
 808     node->setAttribute(SGPropertyNode::WRITE, state);
 809 }
 810
 811 void
 812 fgUntie (const char * name)
 813 {
 814   if (!globals->get_props()->untie(name))
 815     SG_LOG(SG_GENERAL, SG_WARN, "Failed to untie property " << name);
 816 }
 817
 818
 819
 820 \f
 821 ////////////////////////////////////////////////////////////////////////
 822 // Implementation of FGCondition.
 823 ////////////////////////////////////////////////////////////////////////
 824
 825 FGCondition::FGCondition ()
 826 {
 827 }
 828
 829 FGCondition::~FGCondition ()
 830 {
 831 }
 832
 833
 834 \f
 835 ////////////////////////////////////////////////////////////////////////
 836 // Implementation of FGPropertyCondition.
 837 ////////////////////////////////////////////////////////////////////////
 838
 839 FGPropertyCondition::FGPropertyCondition (const char * propname)
 840   : _node(fgGetNode(propname, true))
 841 {
 842 }
 843
 844 FGPropertyCondition::~FGPropertyCondition ()
 845 {
 846 }
 847
 848
 849 \f
 850 ////////////////////////////////////////////////////////////////////////
 851 // Implementation of FGNotCondition.
 852 ////////////////////////////////////////////////////////////////////////
 853
 854 FGNotCondition::FGNotCondition (FGCondition * condition)
 855   : _condition(condition)
 856 {
 857 }
 858
 859 FGNotCondition::~FGNotCondition ()
 860 {
 861   delete _condition;
 862 }
 863
 864 bool
 865 FGNotCondition::test () const
 866 {
 867   return !(_condition->test());
 868 }
 869
 870
 871 \f
 872 ////////////////////////////////////////////////////////////////////////
 873 // Implementation of FGAndCondition.
 874 ////////////////////////////////////////////////////////////////////////
 875
 876 FGAndCondition::FGAndCondition ()
 877 {
 878 }
 879
 880 FGAndCondition::~FGAndCondition ()
 881 {
 882   for (unsigned int i = 0; i < _conditions.size(); i++)
 883     delete _conditions[i];
 884 }
 885
 886 bool
 887 FGAndCondition::test () const
 888 {
 889   int nConditions = _conditions.size();
 890   for (int i = 0; i < nConditions; i++) {
 891     if (!_conditions[i]->test())
 892       return false;
 893   }
 894   return true;
 895 }
 896
 897 void
 898 FGAndCondition::addCondition (FGCondition * condition)
 899 {
 900   _conditions.push_back(condition);
 901 }
 902
 903
 904 \f
 905 ////////////////////////////////////////////////////////////////////////
 906 // Implementation of FGOrCondition.
 907 ////////////////////////////////////////////////////////////////////////
 908
 909 FGOrCondition::FGOrCondition ()
 910 {
 911 }
 912
 913 FGOrCondition::~FGOrCondition ()
 914 {
 915   for (unsigned int i = 0; i < _conditions.size(); i++)
 916     delete _conditions[i];
 917 }
 918
 919 bool
 920 FGOrCondition::test () const
 921 {
 922   int nConditions = _conditions.size();
 923   for (int i = 0; i < nConditions; i++) {
 924     if (_conditions[i]->test())
 925       return true;
 926   }
 927   return false;
 928 }
 929
 930 void
 931 FGOrCondition::addCondition (FGCondition * condition)
 932 {
 933   _conditions.push_back(condition);
 934 }
 935
 936
 937 \f
 938 ////////////////////////////////////////////////////////////////////////
 939 // Implementation of FGComparisonCondition.
 940 ////////////////////////////////////////////////////////////////////////
 941
 942 static int
 943 doComparison (const SGPropertyNode * left, const SGPropertyNode *right)
 944 {
 945   switch (left->getType()) {
 946   case SGPropertyNode::BOOL: {
 947     bool v1 = left->getBoolValue();
 948     bool v2 = right->getBoolValue();
 949     if (v1 < v2)
 950       return FGComparisonCondition::LESS_THAN;
 951     else if (v1 > v2)
 952       return FGComparisonCondition::GREATER_THAN;
 953     else
 954       return FGComparisonCondition::EQUALS;
 955     break;
 956   }
 957   case SGPropertyNode::INT: {
 958     int v1 = left->getIntValue();
 959     int v2 = right->getIntValue();
 960     if (v1 < v2)
 961       return FGComparisonCondition::LESS_THAN;
 962     else if (v1 > v2)
 963       return FGComparisonCondition::GREATER_THAN;
 964     else
 965       return FGComparisonCondition::EQUALS;
 966     break;
 967   }
 968   case SGPropertyNode::LONG: {
 969     long v1 = left->getLongValue();
 970     long v2 = right->getLongValue();
 971     if (v1 < v2)
 972       return FGComparisonCondition::LESS_THAN;
 973     else if (v1 > v2)
 974       return FGComparisonCondition::GREATER_THAN;
 975     else
 976       return FGComparisonCondition::EQUALS;
 977     break;
 978   }
 979   case SGPropertyNode::FLOAT: {
 980     float v1 = left->getFloatValue();
 981     float v2 = right->getFloatValue();
 982     if (v1 < v2)
 983       return FGComparisonCondition::LESS_THAN;
 984     else if (v1 > v2)
 985       return FGComparisonCondition::GREATER_THAN;
 986     else
 987       return FGComparisonCondition::EQUALS;
 988     break;
 989   }
 990   case SGPropertyNode::DOUBLE: {
 991     double v1 = left->getDoubleValue();
 992     double v2 = right->getDoubleValue();
 993     if (v1 < v2)
 994       return FGComparisonCondition::LESS_THAN;
 995     else if (v1 > v2)
 996       return FGComparisonCondition::GREATER_THAN;
 997     else
 998       return FGComparisonCondition::EQUALS;
 999     break;
1000   }
1001   case SGPropertyNode::STRING:
1002   case SGPropertyNode::NONE:
1003   case SGPropertyNode::UNSPECIFIED: {
1004     string v1 = left->getStringValue();
1005     string v2 = right->getStringValue();
1006     if (v1 < v2)
1007       return FGComparisonCondition::LESS_THAN;
1008     else if (v1 > v2)
1009       return FGComparisonCondition::GREATER_THAN;
1010     else
1011       return FGComparisonCondition::EQUALS;
1012     break;
1013   }
1014   }
1015   throw sg_exception("Unrecognized node type");
1016   return 0;
1017 }
1018
1019
1020 FGComparisonCondition::FGComparisonCondition (Type type, bool reverse)
1021   : _type(type),
1022     _reverse(reverse),
1023     _left_property(0),
1024     _right_property(0),
1025     _right_value(0)
1026 {
1027 }
1028
1029 FGComparisonCondition::~FGComparisonCondition ()
1030 {
1031   delete _right_value;
1032 }
1033
1034 bool
1035 FGComparisonCondition::test () const
1036 {
1037                                 // Always fail if incompletely specified
1038   if (_left_property == 0 ||
1039       (_right_property == 0 && _right_value == 0))
1040     return false;
1041
1042                                 // Get LESS_THAN, EQUALS, or GREATER_THAN
1043   int cmp =
1044     doComparison(_left_property,
1045                  (_right_property != 0 ? _right_property : _right_value));
1046   if (!_reverse)
1047     return (cmp == _type);
1048   else
1049     return (cmp != _type);
1050 }
1051
1052 void
1053 FGComparisonCondition::setLeftProperty (const char * propname)
1054 {
1055   _left_property = fgGetNode(propname, true);
1056 }
1057
1058 void
1059 FGComparisonCondition::setRightProperty (const char * propname)
1060 {
1061   delete _right_value;
1062   _right_value = 0;
1063   _right_property = fgGetNode(propname, true);
1064 }
1065
1066 void
1067 FGComparisonCondition::setRightValue (const SGPropertyNode *node)
1068 {
1069   _right_property = 0;
1070   delete _right_value;
1071   _right_value = new SGPropertyNode(*node);
1072 }
1073
1074
1075 \f
1076 ////////////////////////////////////////////////////////////////////////
1077 // Read a condition and use it if necessary.
1078 ////////////////////////////////////////////////////////////////////////
1079
1080                                 // Forward declaration
1081 static FGCondition * readCondition (const SGPropertyNode * node);
1082
1083 static FGCondition *
1084 readPropertyCondition (const SGPropertyNode * node)
1085 {
1086   return new FGPropertyCondition(node->getStringValue());
1087 }
1088
1089 static FGCondition *
1090 readNotCondition (const SGPropertyNode * node)
1091 {
1092   int nChildren = node->nChildren();
1093   for (int i = 0; i < nChildren; i++) {
1094     const SGPropertyNode * child = node->getChild(i);
1095     FGCondition * condition = readCondition(child);
1096     if (condition != 0)
1097       return new FGNotCondition(condition);
1098   }
1099   SG_LOG(SG_COCKPIT, SG_ALERT, "Panel: empty 'not' condition");
1100   return 0;
1101 }
1102
1103 static FGCondition *
1104 readAndConditions (const SGPropertyNode * node)
1105 {
1106   FGAndCondition * andCondition = new FGAndCondition;
1107   int nChildren = node->nChildren();
1108   for (int i = 0; i < nChildren; i++) {
1109     const SGPropertyNode * child = node->getChild(i);
1110     FGCondition * condition = readCondition(child);
1111     if (condition != 0)
1112       andCondition->addCondition(condition);
1113   }
1114   return andCondition;
1115 }
1116
1117 static FGCondition *
1118 readOrConditions (const SGPropertyNode * node)
1119 {
1120   FGOrCondition * orCondition = new FGOrCondition;
1121   int nChildren = node->nChildren();
1122   for (int i = 0; i < nChildren; i++) {
1123     const SGPropertyNode * child = node->getChild(i);
1124     FGCondition * condition = readCondition(child);
1125     if (condition != 0)
1126       orCondition->addCondition(condition);
1127   }
1128   return orCondition;
1129 }
1130
1131 static FGCondition *
1132 readComparison (const SGPropertyNode * node,
1133                 FGComparisonCondition::Type type,
1134                 bool reverse)
1135 {
1136   FGComparisonCondition * condition = new FGComparisonCondition(type, reverse);
1137   condition->setLeftProperty(node->getStringValue("property[0]"));
1138   if (node->hasValue("property[1]"))
1139     condition->setRightProperty(node->getStringValue("property[1]"));
1140   else
1141     condition->setRightValue(node->getChild("value", 0));
1142
1143   return condition;
1144 }
1145
1146 static FGCondition *
1147 readCondition (const SGPropertyNode * node)
1148 {
1149   const string &name = node->getName();
1150   if (name == "property")
1151     return readPropertyCondition(node);
1152   else if (name == "not")
1153     return readNotCondition(node);
1154   else if (name == "and")
1155     return readAndConditions(node);
1156   else if (name == "or")
1157     return readOrConditions(node);
1158   else if (name == "less-than")
1159     return readComparison(node, FGComparisonCondition::LESS_THAN, false);
1160   else if (name == "less-than-equals")
1161     return readComparison(node, FGComparisonCondition::GREATER_THAN, true);
1162   else if (name == "greater-than")
1163     return readComparison(node, FGComparisonCondition::GREATER_THAN, false);
1164   else if (name == "greater-than-equals")
1165     return readComparison(node, FGComparisonCondition::LESS_THAN, true);
1166   else if (name == "equals")
1167     return readComparison(node, FGComparisonCondition::EQUALS, false);
1168   else if (name == "not-equals")
1169     return readComparison(node, FGComparisonCondition::EQUALS, true);
1170   else
1171     return 0;
1172 }
1173
1174
1175 \f
1176 ////////////////////////////////////////////////////////////////////////
1177 // Implementation of FGConditional.
1178 ////////////////////////////////////////////////////////////////////////
1179
1180 FGConditional::FGConditional ()
1181   : _condition (0)
1182 {
1183 }
1184
1185 FGConditional::~FGConditional ()
1186 {
1187   delete _condition;
1188 }
1189
1190 void
1191 FGConditional::setCondition (FGCondition * condition)
1192 {
1193   delete _condition;
1194   _condition = condition;
1195 }
1196
1197 bool
1198 FGConditional::test () const
1199 {
1200   return ((_condition == 0) || _condition->test());
1201 }
1202
1203
1204 \f
1205 // The top-level is always an implicit 'and' group
1206 FGCondition *
1207 fgReadCondition (const SGPropertyNode * node)
1208 {
1209   return readAndConditions(node);
1210 }
1211
1212
1213 // end of fg_props.cxx