src/GUI/FGPUIDialog.cxx

   1 // dialog.cxx: implementation of an XML-configurable dialog box.
   2
   3 #ifdef HAVE_CONFIG_H
   4 #  include "config.h"
   5 #endif
   6
   7 #include <simgear/structure/SGBinding.hxx>
   8 #include <simgear/props/props_io.hxx>
   9 #include <simgear/debug/BufferedLogCallback.hxx>
  10 #include <simgear/scene/tsync/terrasync.hxx>
  11
  12 #include <Scripting/NasalSys.hxx>
  13 #include <Main/fg_os.hxx>
  14 #include <Main/globals.hxx>
  15 #include <Main/fg_props.hxx>
  16
  17 #include "FGPUIDialog.hxx"
  18 #include "new_gui.hxx"
  19 #include "AirportList.hxx"
  20 #include "property_list.hxx"
  21 #include "layout.hxx"
  22 #include "WaypointList.hxx"
  23 #include "CanvasWidget.hxx"
  24 #include "MapWidget.hxx"
  25 #include "FGFontCache.hxx"
  26 #include "FGColor.hxx"
  27
  28 using std::string;
  29
  30 enum format_type { f_INVALID, f_INT, f_LONG, f_FLOAT, f_DOUBLE, f_STRING };
  31 static const int FORMAT_BUFSIZE = 255;
  32 static const int RESIZE_MARGIN = 7;
  33
  34
  35 /**
  36  * Makes sure the format matches '%[ -+#]?\d*(\.\d*)?(l?[df]|s)', with
  37  * only one number or string placeholder and otherwise arbitrary prefix
  38  * and postfix containing only quoted percent signs (%%).
  39  */
  40 static format_type
  41 validate_format(const char *f)
  42 {
  43     bool l = false;
  44     format_type type;
  45     for (; *f; f++) {
  46         if (*f == '%') {
  47             if (f[1] == '%')
  48                 f++;
  49             else
  50                 break;
  51         }
  52     }
  53     if (*f++ != '%')
  54         return f_INVALID;
  55     while (*f == ' ' || *f == '+' || *f == '-' || *f == '#' || *f == '0')
  56         f++;
  57     while (*f && isdigit(*f))
  58         f++;
  59     if (*f == '.') {
  60         f++;
  61         while (*f && isdigit(*f))
  62             f++;
  63     }
  64
  65     if (*f == 'l')
  66         l = true, f++;
  67
  68     if (*f == 'd') {
  69         type = l ? f_LONG : f_INT;
  70     } else if (*f == 'f')
  71         type = l ? f_DOUBLE : f_FLOAT;
  72     else if (*f == 's') {
  73         if (l)
  74             return f_INVALID;
  75         type = f_STRING;
  76     } else
  77         return f_INVALID;
  78
  79     for (++f; *f; f++) {
  80         if (*f == '%') {
  81             if (f[1] == '%')
  82                 f++;
  83             else
  84                 return f_INVALID;
  85         }
  86     }
  87     return type;
  88 }
  89
  90 ////////////////////////////////////////////////////////////////////////
  91
  92 //
  93 // Custom subclass of puPopup to implement "draggable" windows in the
  94 // interface.  Note that this is a subclass of puPopup, not
  95 // puDialogBox.  Sadly, PUI (mis)uses subclassing to implement a
  96 // boolean property: modality.  That means that we can't implement
  97 // dragging of both puPopup windows and puDialogBoxes with the same
  98 // code.  Rather than duplicate code, I've chosen to implement only
  99 // "non-modal dragability" here.  Modal dialog boxes (like the exit
 100 // confirmation) are not draggable.
 101 //
 102 class fgPopup : public puPopup {
 103 public:
 104   fgPopup(int x, int y, bool r = true, bool d = true) :
 105   puPopup(x, y), _draggable(d), _resizable(r), _dragging(false)
 106   {}
 107   int checkHit(int b, int up, int x, int y);
 108   int checkKey(int key, int updown);
 109   int getHitObjects(puObject *, int x, int y);
 110   bool checkHitCanvas(puObject *, int x, int y);
 111   puObject *getKeyObject(puObject *, int key);
 112   puObject *getActiveInputField(puObject *);
 113   void applySize(puObject *);
 114 private:
 115   enum { LEFT = 1, RIGHT = 2, TOP = 4, BOTTOM = 8 };
 116   bool _draggable;
 117   bool _resizable;
 118   bool _dragging;
 119   int _resizing;
 120   int _start_cursor;
 121   int _cursor;
 122   int _dlgX, _dlgY, _dlgW, _dlgH;
 123   int _startX, _startY;
 124 };
 125
 126
 127 class fgValueList {
 128 public:
 129   fgValueList(SGPropertyNode *p);
 130   virtual ~fgValueList();
 131   virtual void update();
 132
 133 protected:
 134   char **_list;
 135
 136 private:
 137   void make_list();
 138   void destroy_list();
 139   SGPropertyNode_ptr _props;
 140 };
 141
 142
 143 class fgList : public fgValueList, public puaList, public GUI_ID {
 144 public:
 145   fgList(int x1, int y1, int x2, int y2, SGPropertyNode *p, int sw) :
 146   fgValueList(p), puaList(x1, y1, x2, y2, _list, sw), GUI_ID(FGCLASS_LIST) {}
 147   void update();
 148 };
 149
 150 class fgComboBox : public fgValueList, public puaComboBox {
 151 public:
 152   fgComboBox(int x1, int y1, int x2, int y2, SGPropertyNode *p, bool editable) :
 153   fgValueList(p),
 154   puaComboBox(x1, y1, x2, y2, _list, editable),
 155   _inHit(false)
 156   {}
 157
 158   void update();
 159
 160   virtual void setSize(int w, int h);
 161
 162   virtual int checkHit(int b, int up, int x, int y);
 163
 164   virtual void recalc_bbox();
 165 private:
 166   bool _inHit;
 167 };
 168
 169 class LogList : public puaList, public FGPUIDialog::ActiveWidget, public GUI_ID {
 170 public:
 171     LogList(int x1, int y1, int x2, int y2, int sw) :
 172         puaList(x1, y1, x2, y2, sw),
 173         GUI_ID(FGCLASS_LOGLIST)
 174     {
 175         m_buffer = NULL;
 176         m_stamp = 0;
 177     }
 178
 179     void setBuffer(simgear::BufferedLogCallback* buf);
 180
 181     virtual void update();
 182 private:
 183     std::vector<unsigned char*> m_items;
 184     simgear::BufferedLogCallback* m_buffer;
 185     unsigned int m_stamp;
 186 };
 187
 188 class fgSelectBox : public fgValueList, public puaSelectBox {
 189 public:
 190   fgSelectBox(int x1, int y1, int x2, int y2, SGPropertyNode *p) :
 191   fgValueList(p), puaSelectBox(x1, y1, x2, y2, _list) {}
 192 };
 193
 194 ////////////////////////////////////////////////////////////////////////
 195 // Implementation of GUIInfo.
 196 ////////////////////////////////////////////////////////////////////////
 197
 198 /**
 199  * User data for a GUI object.
 200  */
 201 struct GUIInfo
 202 {
 203     GUIInfo(FGPUIDialog *d);
 204     virtual ~GUIInfo();
 205     void apply_format(SGPropertyNode *);
 206
 207     FGPUIDialog *dialog;
 208     SGPropertyNode_ptr node;
 209     std::vector <SGBinding *> bindings;
 210     int key;
 211     string label, legend, text, format;
 212     format_type fmt_type;
 213 };
 214
 215 GUIInfo::GUIInfo (FGPUIDialog *d) :
 216     dialog(d),
 217     key(-1),
 218     fmt_type(f_INVALID)
 219 {
 220 }
 221
 222 GUIInfo::~GUIInfo ()
 223 {
 224     for (unsigned int i = 0; i < bindings.size(); i++) {
 225         delete bindings[i];
 226         bindings[i] = 0;
 227     }
 228 }
 229
 230 void GUIInfo::apply_format(SGPropertyNode *n)
 231 {
 232     char buf[FORMAT_BUFSIZE + 1];
 233     if (fmt_type == f_INT)
 234         snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getIntValue());
 235     else if (fmt_type == f_LONG)
 236         snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getLongValue());
 237     else if (fmt_type == f_FLOAT)
 238         snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getFloatValue());
 239     else if (fmt_type == f_DOUBLE)
 240         snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getDoubleValue());
 241     else
 242         snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getStringValue());
 243
 244     buf[FORMAT_BUFSIZE] = '\0';
 245     text = buf;
 246 }
 247
 248
 249 /**
 250  * Key handler.
 251  */
 252 int fgPopup::checkKey(int key, int updown)
 253 {
 254     if (updown == PU_UP || !isVisible() || !isActive() || window != puGetWindow())
 255         return false;
 256
 257     puObject *input = getActiveInputField(this);
 258     if (input)
 259         return input->checkKey(key, updown);
 260
 261     puObject *object = getKeyObject(this, key);
 262     if (!object)
 263         return puPopup::checkKey(key, updown);
 264
 265     // invokeCallback() isn't enough; we need to simulate a mouse button press
 266     object->checkHit(PU_LEFT_BUTTON, PU_DOWN,
 267             (object->getABox()->min[0] + object->getABox()->max[0]) / 2,
 268             (object->getABox()->min[1] + object->getABox()->max[1]) / 2);
 269     object->checkHit(PU_LEFT_BUTTON, PU_UP,
 270             (object->getABox()->min[0] + object->getABox()->max[0]) / 2,
 271             (object->getABox()->min[1] + object->getABox()->max[1]) / 2);
 272     return true;
 273 }
 274
 275 puObject *fgPopup::getKeyObject(puObject *object, int key)
 276 {
 277     puObject *ret;
 278     if (object->getType() & PUCLASS_GROUP)
 279         for (puObject *obj = ((puGroup *)object)->getFirstChild();
 280                 obj; obj = obj->getNextObject())
 281             if ((ret = getKeyObject(obj, key)))
 282                 return ret;
 283
 284     GUIInfo *info = (GUIInfo *)object->getUserData();
 285     if (info && info->key == key)
 286         return object;
 287
 288     return 0;
 289 }
 290
 291 puObject *fgPopup::getActiveInputField(puObject *object)
 292 {
 293     puObject *ret;
 294     if (object->getType() & PUCLASS_GROUP)
 295         for (puObject *obj = ((puGroup *)object)->getFirstChild();
 296                 obj; obj = obj->getNextObject())
 297             if ((ret = getActiveInputField(obj)))
 298                 return ret;
 299
 300     if (object->getType() & (PUCLASS_INPUT|PUCLASS_LARGEINPUT)
 301             && ((puInput *)object)->isAcceptingInput())
 302         return object;
 303
 304     return 0;
 305 }
 306
 307 /**
 308  * Mouse handler.
 309  */
 310 int fgPopup::checkHit(int button, int updown, int x, int y)
 311 {
 312     int result = 0;
 313     if (updown != PU_DRAG && !_dragging)
 314         result = puPopup::checkHit(button, updown, x, y);
 315
 316     if (!_draggable)
 317        return result;
 318
 319     // This is annoying.  We would really want a true result from the
 320     // superclass to indicate "handled by child object", but all it
 321     // tells us is that the pointer is inside the dialog.  So do the
 322     // intersection test (again) to make sure we don't start a drag
 323     // when inside controls.
 324
 325     if (updown == PU_DOWN && !_dragging) {
 326         if (!result)
 327             return 0;
 328         int global_drag = fgGetKeyModifiers() & KEYMOD_SHIFT;
 329         int global_resize = fgGetKeyModifiers() & KEYMOD_CTRL;
 330
 331         int hit = getHitObjects(this, x, y);
 332         if (hit & PUCLASS_LIST)  // ctrl-click in property browser (toggle bool)
 333             return result;
 334         if(    !global_resize
 335             && (  (hit & (PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
 336                          |PUCLASS_LARGEINPUT|PUCLASS_SCROLLBAR))
 337                   // The canvas should handle drag events on its own so exit
 338                   // here if mouse is over a CanvasWidget
 339                || (!global_drag && checkHitCanvas(this, x, y))
 340                ) )
 341         {
 342             return result;
 343         }
 344
 345         getPosition(&_dlgX, &_dlgY);
 346         getSize(&_dlgW, &_dlgH);
 347         _start_cursor = fgGetMouseCursor();
 348         _dragging = true;
 349         _startX = x;
 350         _startY = y;
 351
 352         // check and prepare for resizing
 353         static const int cursor[] = {
 354             MOUSE_CURSOR_POINTER, MOUSE_CURSOR_LEFTSIDE, MOUSE_CURSOR_RIGHTSIDE, 0,
 355             MOUSE_CURSOR_TOPSIDE, MOUSE_CURSOR_TOPLEFT, MOUSE_CURSOR_TOPRIGHT, 0,
 356             MOUSE_CURSOR_BOTTOMSIDE, MOUSE_CURSOR_BOTTOMLEFT, MOUSE_CURSOR_BOTTOMRIGHT, 0,
 357         };
 358
 359         _resizing = 0;
 360         if (!global_drag && _resizable) {
 361             int hmargin = global_resize ? _dlgW / 3 : RESIZE_MARGIN;
 362             int vmargin = global_resize ? _dlgH / 3 : RESIZE_MARGIN;
 363
 364             if (y - _dlgY < vmargin)
 365                 _resizing |= BOTTOM;
 366             else if (_dlgY + _dlgH - y < vmargin)
 367                 _resizing |= TOP;
 368
 369             if (x - _dlgX < hmargin)
 370                 _resizing |= LEFT;
 371             else if (_dlgX + _dlgW - x < hmargin)
 372                 _resizing |= RIGHT;
 373
 374             if (!_resizing && global_resize)
 375                 _resizing = BOTTOM|RIGHT;
 376
 377             _cursor = cursor[_resizing];
 378            if (_resizing && _resizable)
 379                 fgSetMouseCursor(_cursor);
 380        }
 381
 382     } else if (updown == PU_DRAG && _dragging) {
 383         if (_resizing) {
 384             GUIInfo *info = (GUIInfo *)getUserData();
 385             if (_resizable && info && info->node) {
 386                 int w = _dlgW;
 387                 int h = _dlgH;
 388                 if (_resizing & LEFT)
 389                     w += _startX - x;
 390                 if (_resizing & RIGHT)
 391                     w += x - _startX;
 392                 if (_resizing & TOP)
 393                     h += y - _startY;
 394                 if (_resizing & BOTTOM)
 395                     h += _startY - y;
 396
 397                 int prefw, prefh;
 398                 LayoutWidget wid(info->node);
 399                 wid.calcPrefSize(&prefw, &prefh);
 400                 if (w < prefw)
 401                     w = prefw;
 402                 if (h < prefh)
 403                     h = prefh;
 404
 405                 int x = _dlgX;
 406                 int y = _dlgY;
 407                 if (_resizing & LEFT)
 408                     x += _dlgW - w;
 409                 if (_resizing & BOTTOM)
 410                     y += _dlgH - h;
 411
 412                 wid.layout(x, y, w, h);
 413                 setSize(w, h);
 414                 setPosition(x, y);
 415                 applySize(static_cast<puObject *>(this));
 416                 getFirstChild()->setSize(w, h); // dialog background puFrame
 417             }
 418         } else {
 419             int posX = x + _dlgX - _startX,
 420               posY = y + _dlgY - _startY;
 421             setPosition(posX, posY);
 422
 423             GUIInfo *info = (GUIInfo *)getUserData();
 424             if (info && info->node) {
 425                 info->node->setIntValue("x", posX);
 426                 info->node->setIntValue("y", posY);
 427             }
 428         } // re-positioning
 429
 430     } else if (_dragging) {
 431         fgSetMouseCursor(_start_cursor);
 432         _dragging = false;
 433     }
 434     return result;
 435 }
 436
 437 int fgPopup::getHitObjects(puObject *object, int x, int y)
 438 {
 439     if (!object->isVisible())
 440         return 0;
 441
 442     int type = 0;
 443     if (object->getType() & PUCLASS_GROUP)
 444         for (puObject *obj = ((puGroup *)object)->getFirstChild();
 445                 obj; obj = obj->getNextObject())
 446             type |= getHitObjects(obj, x, y);
 447
 448     int cx, cy, cw, ch;
 449     object->getAbsolutePosition(&cx, &cy);
 450     object->getSize(&cw, &ch);
 451     if (x >= cx && x < cx + cw && y >= cy && y < cy + ch)
 452         type |= object->getType();
 453     return type;
 454 }
 455
 456 bool fgPopup::checkHitCanvas(puObject* object, int x, int y)
 457 {
 458   if( !object->isVisible() )
 459     return 0;
 460
 461   if( object->getType() & PUCLASS_GROUP )
 462   {
 463     for( puObject* obj = ((puGroup*)object)->getFirstChild();
 464                    obj;
 465                    obj = obj->getNextObject() )
 466     {
 467       if( checkHitCanvas(obj, x, y) )
 468         return true;
 469     }
 470   }
 471
 472   int cx, cy, cw, ch;
 473   object->getAbsolutePosition(&cx, &cy);
 474   object->getSize(&cw, &ch);
 475   if(    x >= cx && x < cx + cw
 476       && y >= cy && y < cy + ch
 477       && dynamic_cast<CanvasWidget*>(object) )
 478     return true;
 479   return false;
 480 }
 481
 482 void fgPopup::applySize(puObject *object)
 483 {
 484     // compound plib widgets use setUserData() for internal purposes, so refuse
 485     // to descend into anything that has other bits set than the following
 486     const int validUserData = PUCLASS_VALUE|PUCLASS_OBJECT|PUCLASS_GROUP|PUCLASS_INTERFACE
 487             |PUCLASS_FRAME|PUCLASS_TEXT|PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
 488             |PUCLASS_ARROW|PUCLASS_DIAL|PUCLASS_POPUP;
 489
 490     int type = object->getType();
 491     if (type & PUCLASS_GROUP && !(type & ~validUserData))
 492         for (puObject *obj = ((puGroup *)object)->getFirstChild();
 493                 obj; obj = obj->getNextObject())
 494             applySize(obj);
 495
 496     GUIInfo *info = (GUIInfo *)object->getUserData();
 497     if (!info)
 498         return;
 499
 500     SGPropertyNode *n = info->node;
 501     if (!n) {
 502         SG_LOG(SG_GENERAL, SG_ALERT, "fgPopup::applySize: no props");
 503         return;
 504     }
 505     int x = n->getIntValue("x");
 506     int y = n->getIntValue("y");
 507     int w = n->getIntValue("width", 4);
 508     int h = n->getIntValue("height", 4);
 509     object->setPosition(x, y);
 510     object->setSize(w, h);
 511 }
 512
 513 ////////////////////////////////////////////////////////////////////////
 514
 515 void FGPUIDialog::ConditionalObject::update(FGPUIDialog* aDlg)
 516 {
 517   if (_name == "visible") {
 518     bool wasVis = _pu->isVisible() != 0;
 519     bool newVis = test();
 520
 521     if (newVis == wasVis) {
 522       return;
 523     }
 524
 525     if (newVis) { // puObject needs a setVisible. Oh well.
 526     _pu->reveal();
 527     } else {
 528       _pu->hide();
 529     }
 530   } else if (_name == "enable") {
 531     bool wasEnabled = _pu->isActive() != 0;
 532     bool newEnable = test();
 533
 534     if (wasEnabled == newEnable) {
 535       return;
 536     }
 537
 538     if (newEnable) {
 539       _pu->activate();
 540     } else {
 541       _pu->greyOut();
 542     }
 543   }
 544
 545   aDlg->setNeedsLayout();
 546 }
 547
 548 ////////////////////////////////////////////////////////////////////////
 549 // Callbacks.
 550 ////////////////////////////////////////////////////////////////////////
 551
 552 /**
 553  * Action callback.
 554  */
 555 static void
 556 action_callback (puObject *object)
 557 {
 558     GUIInfo *info = (GUIInfo *)object->getUserData();
 559     NewGUI *gui = (NewGUI *)globals->get_subsystem("gui");
 560     gui->setActiveDialog(info->dialog);
 561     int nBindings = info->bindings.size();
 562     for (int i = 0; i < nBindings; i++) {
 563         info->bindings[i]->fire();
 564         if (gui->getActiveDialog() == 0)
 565             break;
 566     }
 567     gui->setActiveDialog(0);
 568 }
 569
 570
 571 ////////////////////////////////////////////////////////////////////////
 572 // Static helper functions.
 573 ////////////////////////////////////////////////////////////////////////
 574
 575 /**
 576  * Copy a property value to a PUI object.
 577  */
 578 static void
 579 copy_to_pui (SGPropertyNode *node, puObject *object)
 580 {
 581     using namespace simgear;
 582     GUIInfo *info = (GUIInfo *)object->getUserData();
 583     if (!info) {
 584         SG_LOG(SG_GENERAL, SG_ALERT, "dialog: widget without GUIInfo!");
 585         return;   // this can't really happen
 586     }
 587
 588     // Treat puText objects specially, so their "values" can be set
 589     // from properties.
 590     if (object->getType() & PUCLASS_TEXT) {
 591         if (info->fmt_type != f_INVALID)
 592             info->apply_format(node);
 593         else
 594             info->text = node->getStringValue();
 595
 596         object->setLabel(info->text.c_str());
 597         return;
 598     }
 599
 600     switch (node->getType()) {
 601     case props::BOOL:
 602     case props::INT:
 603     case props::LONG:
 604         object->setValue(node->getIntValue());
 605         break;
 606     case props::FLOAT:
 607     case props::DOUBLE:
 608         object->setValue(node->getFloatValue());
 609         break;
 610     default:
 611         info->text = node->getStringValue();
 612         object->setValue(info->text.c_str());
 613         break;
 614     }
 615 }
 616
 617
 618 static void
 619 copy_from_pui (puObject *object, SGPropertyNode *node)
 620 {
 621     using namespace simgear;
 622     // puText objects are immutable, so should not be copied out
 623     if (object->getType() & PUCLASS_TEXT)
 624         return;
 625
 626     switch (node->getType()) {
 627     case props::BOOL:
 628     case props::INT:
 629     case props::LONG:
 630         node->setIntValue(object->getIntegerValue());
 631         break;
 632     case props::FLOAT:
 633         node->setFloatValue(object->getFloatValue());
 634         break;
 635     case props::DOUBLE:
 636     {
 637         // puObject only provides float, not double, which causes precision/rounding issues
 638         // with some numerical values (try "114.2").
 639         // Work around: obtain string value, and manually convert with proper double precision.
 640         const char *s = object->getStringValue();
 641         node->setDoubleValue(atof(s));
 642         break;
 643     }
 644     default:
 645         const char *s = object->getStringValue();
 646         if (s)
 647             node->setStringValue(s);
 648         break;
 649     }
 650 }
 651
 652
 653 ////////////////////////////////////////////////////////////////////////
 654 // Implementation of FGDialog.
 655 ////////////////////////////////////////////////////////////////////////
 656
 657 FGPUIDialog::FGPUIDialog (SGPropertyNode *props) :
 658     FGDialog(props),
 659     _object(0),
 660     _gui((NewGUI *)globals->get_subsystem("gui")),
 661     _props(props),
 662     _needsRelayout(false)
 663 {
 664     _module = string("__dlg:") + props->getStringValue("name", "[unnamed]");
 665
 666     SGPropertyNode *nasal = props->getNode("nasal");
 667     if (nasal) {
 668         _nasal_close = nasal->getNode("close");
 669         SGPropertyNode *open = nasal->getNode("open");
 670         if (open) {
 671             const char *s = open->getStringValue();
 672             FGNasalSys *nas = (FGNasalSys *)globals->get_subsystem("nasal");
 673             if (nas)
 674                 nas->createModule(_module.c_str(), _module.c_str(), s, strlen(s), props);
 675         }
 676     }
 677     display(props);
 678 }
 679
 680 FGPUIDialog::~FGPUIDialog ()
 681 {
 682     int x, y;
 683     _object->getAbsolutePosition(&x, &y);
 684     _props->setIntValue("lastx", x);
 685     _props->setIntValue("lasty", y);
 686
 687     FGNasalSys *nas = (FGNasalSys *)globals->get_subsystem("nasal");
 688     if (nas) {
 689         if (_nasal_close) {
 690             const char *s = _nasal_close->getStringValue();
 691             nas->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _props);
 692         }
 693         nas->deleteModule(_module.c_str());
 694     }
 695
 696     puDeleteObject(_object);
 697
 698     unsigned int i;
 699                                 // Delete all the info objects we
 700                                 // were forced to keep around because
 701                                 // PUI cannot delete its own user data.
 702     for (i = 0; i < _info.size(); i++) {
 703         delete (GUIInfo *)_info[i];
 704         _info[i] = 0;
 705     }
 706                                 // Finally, delete the property links.
 707     for (i = 0; i < _propertyObjects.size(); i++) {
 708         delete _propertyObjects[i];
 709         _propertyObjects[i] = 0;
 710     }
 711 }
 712
 713 void
 714 FGPUIDialog::updateValues (const char *objectName)
 715 {
 716     if (objectName && !objectName[0])
 717         objectName = 0;
 718
 719   for (unsigned int i = 0; i < _propertyObjects.size(); i++) {
 720     const string &name = _propertyObjects[i]->name;
 721     if (objectName && name != objectName) {
 722       continue;
 723     }
 724
 725     puObject *widget = _propertyObjects[i]->object;
 726     int widgetType = widget->getType();
 727     if (widgetType & PUCLASS_LIST) {
 728       GUI_ID* gui_id = dynamic_cast<GUI_ID *>(widget);
 729       if (gui_id && (gui_id->id & FGCLASS_LIST)) {
 730         fgList *pl = static_cast<fgList*>(widget);
 731         pl->update();
 732       } else {
 733         copy_to_pui(_propertyObjects[i]->node, widget);
 734       }
 735     } else if (widgetType & PUCLASS_COMBOBOX) {
 736       fgComboBox* combo = static_cast<fgComboBox*>(widget);
 737       combo->update();
 738     } else {
 739       copy_to_pui(_propertyObjects[i]->node, widget);
 740     }
 741   } // of property objects iteration
 742 }
 743
 744 void
 745 FGPUIDialog::applyValues (const char *objectName)
 746 {
 747     if (objectName && !objectName[0])
 748         objectName = 0;
 749
 750     for (unsigned int i = 0; i < _propertyObjects.size(); i++) {
 751         const string &name = _propertyObjects[i]->name;
 752         if (objectName && name != objectName)
 753             continue;
 754
 755         copy_from_pui(_propertyObjects[i]->object,
 756                       _propertyObjects[i]->node);
 757     }
 758 }
 759
 760 void
 761 FGPUIDialog::update ()
 762 {
 763     for (unsigned int i = 0; i < _liveObjects.size(); i++) {
 764         puObject *obj = _liveObjects[i]->object;
 765         if (obj->getType() & PUCLASS_INPUT && ((puInput *)obj)->isAcceptingInput())
 766             continue;
 767
 768         copy_to_pui(_liveObjects[i]->node, obj);
 769     }
 770
 771   for (unsigned int j=0; j < _conditionalObjects.size(); ++j) {
 772     _conditionalObjects[j]->update(this);
 773   }
 774
 775   for (unsigned int i = 0; i < _activeWidgets.size(); i++) {
 776     _activeWidgets[i]->update();
 777   }
 778
 779   if (_needsRelayout) {
 780     relayout();
 781   }
 782 }
 783
 784 void
 785 FGPUIDialog::display (SGPropertyNode *props)
 786 {
 787     if (_object != 0) {
 788         SG_LOG(SG_GENERAL, SG_ALERT, "This widget is already active");
 789         return;
 790     }
 791
 792     int screenw = globals->get_props()->getIntValue("/sim/startup/xsize");
 793     int screenh = globals->get_props()->getIntValue("/sim/startup/ysize");
 794
 795     bool userx = props->hasValue("x");
 796     bool usery = props->hasValue("y");
 797     bool userw = props->hasValue("width");
 798     bool userh = props->hasValue("height");
 799
 800     // Let the layout widget work in the same property subtree.
 801     LayoutWidget wid(props);
 802
 803     SGPropertyNode *fontnode = props->getNode("font");
 804     if (fontnode) {
 805         FGFontCache *fc = globals->get_fontcache();
 806         _font = fc->get(fontnode);
 807     } else {
 808         _font = _gui->getDefaultFont();
 809     }
 810     wid.setDefaultFont(_font, int(_font->getPointSize()));
 811
 812     int pw = 0, ph = 0;
 813     int px, py, savex, savey;
 814     if (!userw || !userh)
 815         wid.calcPrefSize(&pw, &ph);
 816     pw = props->getIntValue("width", pw);
 817     ph = props->getIntValue("height", ph);
 818     px = savex = props->getIntValue("x", (screenw - pw) / 2);
 819     py = savey = props->getIntValue("y", (screenh - ph) / 2);
 820
 821     // Negative x/y coordinates are interpreted as distance from the top/right
 822     // corner rather than bottom/left.
 823     if (userx && px < 0)
 824         px = screenw - pw + px;
 825     if (usery && py < 0)
 826         py = screenh - ph + py;
 827
 828     // Define "x", "y", "width" and/or "height" in the property tree if they
 829     // are not specified in the configuration file.
 830     wid.layout(px, py, pw, ph);
 831
 832     // Use the dimension and location properties as specified in the
 833     // configuration file or from the layout widget.
 834     _object = makeObject(props, screenw, screenh);
 835
 836     // Remove automatically generated properties, so the layout looks
 837     // the same next time around, or restore x and y to preserve negative coords.
 838     if (userx)
 839         props->setIntValue("x", savex);
 840     else
 841         props->removeChild("x");
 842
 843     if (usery)
 844         props->setIntValue("y", savey);
 845     else
 846         props->removeChild("y");
 847
 848     if (!userw) props->removeChild("width");
 849     if (!userh) props->removeChild("height");
 850
 851     if (_object != 0) {
 852         _object->reveal();
 853     } else {
 854         SG_LOG(SG_GENERAL, SG_ALERT, "Widget "
 855                << props->getStringValue("name", "[unnamed]")
 856                << " does not contain a proper GUI definition");
 857     }
 858 }
 859
 860 puObject *
 861 FGPUIDialog::makeObject (SGPropertyNode *props, int parentWidth, int parentHeight)
 862 {
 863     if (!props->getBoolValue("enabled", true))
 864         return 0;
 865
 866     bool presetSize = props->hasValue("width") && props->hasValue("height");
 867     int width = props->getIntValue("width", parentWidth);
 868     int height = props->getIntValue("height", parentHeight);
 869     int x = props->getIntValue("x", (parentWidth - width) / 2);
 870     int y = props->getIntValue("y", (parentHeight - height) / 2);
 871     string type = props->getName();
 872
 873     if (type.empty())
 874         type = "dialog";
 875
 876     if (type == "dialog") {
 877         puPopup *obj;
 878         bool draggable = props->getBoolValue("draggable", true);
 879         bool resizable = props->getBoolValue("resizable", false);
 880         if (props->getBoolValue("modal", false))
 881             obj = new puDialogBox(x, y);
 882         else
 883             obj = new fgPopup(x, y, resizable, draggable);
 884         setupGroup(obj, props, width, height, true);
 885         setColor(obj, props);
 886         return obj;
 887
 888     } else if (type == "group") {
 889         puGroup *obj = new puGroup(x, y);
 890         setupGroup(obj, props, width, height, false);
 891         setColor(obj, props);
 892         return obj;
 893
 894     } else if (type == "frame") {
 895         puGroup *obj = new puGroup(x, y);
 896         setupGroup(obj, props, width, height, true);
 897         setColor(obj, props);
 898         return obj;
 899
 900     } else if (type == "hrule" || type == "vrule") {
 901         puFrame *obj = new puFrame(x, y, x + width, y + height);
 902         obj->setBorderThickness(0);
 903         setupObject(obj, props);
 904         setColor(obj, props, BACKGROUND|FOREGROUND|HIGHLIGHT);
 905         return obj;
 906
 907     } else if (type == "list") {
 908         int slider_width = props->getIntValue("slider", 20);
 909         fgList *obj = new fgList(x, y, x + width, y + height, props, slider_width);
 910         if (presetSize)
 911             obj->setSize(width, height);
 912         setupObject(obj, props);
 913         setColor(obj, props);
 914         return obj;
 915
 916     } else if (type == "airport-list") {
 917         AirportList *obj = new AirportList(x, y, x + width, y + height);
 918         if (presetSize)
 919             obj->setSize(width, height);
 920         setupObject(obj, props);
 921         setColor(obj, props);
 922         return obj;
 923
 924     } else if (type == "property-list") {
 925         PropertyList *obj = new PropertyList(x, y, x + width, y + height, globals->get_props());
 926         if (presetSize)
 927             obj->setSize(width, height);
 928         setupObject(obj, props);
 929         setColor(obj, props);
 930         return obj;
 931
 932     } else if (type == "input") {
 933         puInput *obj = new puInput(x, y, x + width, y + height);
 934         setupObject(obj, props);
 935         setColor(obj, props, FOREGROUND|LABEL);
 936         return obj;
 937
 938     } else if (type == "text") {
 939         puText *obj = new puText(x, y);
 940         setupObject(obj, props);
 941
 942         // Layed-out objects need their size set, and non-layout ones
 943         // get a different placement.
 944         if (presetSize)
 945             obj->setSize(width, height);
 946         else
 947             obj->setLabelPlace(PUPLACE_LABEL_DEFAULT);
 948         setColor(obj, props, LABEL);
 949         return obj;
 950
 951     } else if (type == "checkbox") {
 952         puButton *obj;
 953         obj = new puButton(x, y, x + width, y + height, PUBUTTON_XCHECK);
 954         setupObject(obj, props);
 955         setColor(obj, props, FOREGROUND|LABEL);
 956         return obj;
 957
 958     } else if (type == "radio") {
 959         puButton *obj;
 960         obj = new puButton(x, y, x + width, y + height, PUBUTTON_CIRCLE);
 961         setupObject(obj, props);
 962         setColor(obj, props, FOREGROUND|LABEL);
 963         return obj;
 964
 965     } else if (type == "button") {
 966         puButton *obj;
 967         const char *legend = props->getStringValue("legend", "[none]");
 968         if (props->getBoolValue("one-shot", true))
 969             obj = new puOneShot(x, y, legend);
 970         else
 971             obj = new puButton(x, y, legend);
 972         if (presetSize)
 973             obj->setSize(width, height);
 974         setupObject(obj, props);
 975         setColor(obj, props);
 976         return obj;
 977     } else if (type == "map") {
 978         MapWidget* mapWidget = new MapWidget(x, y, x + width, y + height);
 979         setupObject(mapWidget, props);
 980         return mapWidget;
 981     } else if (type == "canvas") {
 982         CanvasWidget* canvasWidget = new CanvasWidget( x, y,
 983                                                        x + width, y + height,
 984                                                        props,
 985                                                        _module );
 986         setupObject(canvasWidget, props);
 987         return canvasWidget;
 988     } else if (type == "combo") {
 989         fgComboBox *obj = new fgComboBox(x, y, x + width, y + height, props,
 990                 props->getBoolValue("editable", false));
 991         setupObject(obj, props);
 992         setColor(obj, props, EDITFIELD);
 993         return obj;
 994
 995     } else if (type == "slider") {
 996         bool vertical = props->getBoolValue("vertical", false);
 997         puSlider *obj = new puSlider(x, y, (vertical ? height : width), vertical);
 998         obj->setMinValue(props->getFloatValue("min", 0.0));
 999         obj->setMaxValue(props->getFloatValue("max", 1.0));
1000         obj->setStepSize(props->getFloatValue("step"));
1001         obj->setSliderFraction(props->getFloatValue("fraction"));
1002 #if PLIB_VERSION > 185
1003         obj->setPageStepSize(props->getFloatValue("pagestep"));
1004 #endif
1005         setupObject(obj, props);
1006         if (presetSize)
1007             obj->setSize(width, height);
1008         setColor(obj, props, FOREGROUND|LABEL);
1009         return obj;
1010
1011     } else if (type == "dial") {
1012         puDial *obj = new puDial(x, y, width);
1013         obj->setMinValue(props->getFloatValue("min", 0.0));
1014         obj->setMaxValue(props->getFloatValue("max", 1.0));
1015         obj->setWrap(props->getBoolValue("wrap", true));
1016         setupObject(obj, props);
1017         setColor(obj, props, FOREGROUND|LABEL);
1018         return obj;
1019
1020     } else if (type == "textbox") {
1021         int slider_width = props->getIntValue("slider", 20);
1022         int wrap = props->getBoolValue("wrap", true);
1023 #if PLIB_VERSION > 185
1024         puaLargeInput *obj = new puaLargeInput(x, y,
1025                 x + width, x + height, 11, slider_width, wrap);
1026 #else
1027         puaLargeInput *obj = new puaLargeInput(x, y,
1028                 x + width, x + height, 2, slider_width, wrap);
1029 #endif
1030
1031         if (props->getBoolValue("editable"))
1032             obj->enableInput();
1033         else
1034             obj->disableInput();
1035
1036         if (presetSize)
1037             obj->setSize(width, height);
1038         setupObject(obj, props);
1039         setColor(obj, props, FOREGROUND|LABEL);
1040
1041         int top = props->getIntValue("top-line", 0);
1042         obj->setTopLineInWindow(top < 0 ? unsigned(-1) >> 1 : top);
1043         return obj;
1044
1045     } else if (type == "select") {
1046         fgSelectBox *obj = new fgSelectBox(x, y, x + width, y + height, props);
1047         setupObject(obj, props);
1048         setColor(obj, props, EDITFIELD);
1049         return obj;
1050     } else if (type == "waypointlist") {
1051         ScrolledWaypointList* obj = new ScrolledWaypointList(x, y, width, height);
1052         setupObject(obj, props);
1053         return obj;
1054
1055     } else if (type == "loglist") {
1056         LogList* obj = new LogList(x, y, width, height, 20);
1057         string logClass = props->getStringValue("logclass");
1058         if (logClass == "terrasync") {
1059           simgear::SGTerraSync* tsync = (simgear::SGTerraSync*) globals->get_subsystem("terrasync");
1060           obj->setBuffer(tsync->log());
1061         } else {
1062           FGNasalSys* nasal = (FGNasalSys*) globals->get_subsystem("nasal");
1063           obj->setBuffer(nasal->log());
1064         }
1065
1066         setupObject(obj, props);
1067         _activeWidgets.push_back(obj);
1068         return obj;
1069     } else {
1070         return 0;
1071     }
1072 }
1073
1074 void
1075 FGPUIDialog::setupObject (puObject *object, SGPropertyNode *props)
1076 {
1077     GUIInfo *info = new GUIInfo(this);
1078     object->setUserData(info);
1079     _info.push_back(info);
1080     object->setLabelPlace(PUPLACE_CENTERED_RIGHT);
1081     object->makeReturnDefault(props->getBoolValue("default"));
1082     info->node = props;
1083
1084     if (props->hasValue("legend")) {
1085         info->legend = props->getStringValue("legend");
1086         object->setLegend(info->legend.c_str());
1087     }
1088
1089     if (props->hasValue("label")) {
1090         info->label = props->getStringValue("label");
1091         object->setLabel(info->label.c_str());
1092     }
1093
1094     if (props->hasValue("border"))
1095         object->setBorderThickness( props->getIntValue("border", 2) );
1096
1097     if (SGPropertyNode *nft = props->getNode("font", false)) {
1098        FGFontCache *fc = globals->get_fontcache();
1099        puFont *lfnt = fc->get(nft);
1100        object->setLabelFont(*lfnt);
1101        object->setLegendFont(*lfnt);
1102     } else {
1103        object->setLabelFont(*_font);
1104     }
1105
1106     if (props->hasChild("visible")) {
1107       ConditionalObject* cnd = new ConditionalObject("visible", object);
1108       cnd->setCondition(sgReadCondition(globals->get_props(), props->getChild("visible")));
1109       _conditionalObjects.push_back(cnd);
1110     }
1111
1112     if (props->hasChild("enable")) {
1113       ConditionalObject* cnd = new ConditionalObject("enable", object);
1114       cnd->setCondition(sgReadCondition(globals->get_props(), props->getChild("enable")));
1115       _conditionalObjects.push_back(cnd);
1116     }
1117
1118     string type = props->getName();
1119     if (type == "input" && props->getBoolValue("live"))
1120         object->setDownCallback(action_callback);
1121
1122     if (type == "text") {
1123         const char *format = props->getStringValue("format", 0);
1124         if (format) {
1125             info->fmt_type = validate_format(format);
1126             if (info->fmt_type != f_INVALID)
1127                 info->format = format;
1128             else
1129                 SG_LOG(SG_GENERAL, SG_ALERT, "DIALOG: invalid <format> '"
1130                         << format << '\'');
1131         }
1132     }
1133
1134     if (props->hasValue("property")) {
1135         const char *name = props->getStringValue("name");
1136         if (name == 0)
1137             name = "";
1138         const char *propname = props->getStringValue("property");
1139         SGPropertyNode_ptr node = fgGetNode(propname, true);
1140         if (type == "map") {
1141           // mapWidget binds to a sub-tree of properties, and
1142           // ignores the puValue mechanism, so special case things here
1143           MapWidget* mw = static_cast<MapWidget*>(object);
1144           mw->setProperty(node);
1145         } else {
1146             // normal widget, creating PropertyObject
1147             copy_to_pui(node, object);
1148             PropertyObject *po = new PropertyObject(name, object, node);
1149             _propertyObjects.push_back(po);
1150             if (props->getBoolValue("live"))
1151                 _liveObjects.push_back(po);
1152         }
1153
1154
1155     }
1156
1157     SGPropertyNode *dest = fgGetNode("/sim/bindings/gui", true);
1158     std::vector<SGPropertyNode_ptr> bindings = props->getChildren("binding");
1159     if (bindings.size() > 0) {
1160         info->key = props->getIntValue("keynum", -1);
1161         if (props->hasValue("key"))
1162             info->key = getKeyCode(props->getStringValue("key", ""));
1163
1164         for (unsigned int i = 0; i < bindings.size(); i++) {
1165             unsigned int j = 0;
1166             SGPropertyNode_ptr binding;
1167             while (dest->getChild("binding", j))
1168                 j++;
1169
1170             const char *cmd = bindings[i]->getStringValue("command");
1171             if (!strcmp(cmd, "nasal"))
1172                 bindings[i]->setStringValue("module", _module.c_str());
1173
1174             binding = dest->getChild("binding", j, true);
1175             copyProperties(bindings[i], binding);
1176             info->bindings.push_back(new SGBinding(binding, globals->get_props()));
1177         }
1178         object->setCallback(action_callback);
1179     }
1180 }
1181
1182 void
1183 FGPUIDialog::setupGroup(puGroup *group, SGPropertyNode *props,
1184        int width, int height, bool makeFrame)
1185 {
1186     setupObject(group, props);
1187
1188     if (makeFrame) {
1189         puFrame* f = new puFrame(0, 0, width, height);
1190         setColor(f, props);
1191     }
1192
1193     int nChildren = props->nChildren();
1194     for (int i = 0; i < nChildren; i++)
1195         makeObject(props->getChild(i), width, height);
1196     group->close();
1197 }
1198
1199 void
1200 FGPUIDialog::setColor(puObject *object, SGPropertyNode *props, int which)
1201 {
1202     string type = props->getName();
1203     if (type.empty())
1204         type = "dialog";
1205     if (type == "textbox" && props->getBoolValue("editable"))
1206         type += "-editable";
1207
1208     FGColor c(_gui->getColor("background"));
1209     c.merge(_gui->getColor(type));
1210     c.merge(props->getNode("color"));
1211     if (c.isValid())
1212         object->setColourScheme(c.red(), c.green(), c.blue(), c.alpha());
1213
1214     const struct {
1215         int mask;
1216         int id;
1217         const char *name;
1218         const char *cname;
1219     } pucol[] = {
1220         { BACKGROUND, PUCOL_BACKGROUND, "background", "color-background" },
1221         { FOREGROUND, PUCOL_FOREGROUND, "foreground", "color-foreground" },
1222         { HIGHLIGHT,  PUCOL_HIGHLIGHT,  "highlight",  "color-highlight" },
1223         { LABEL,      PUCOL_LABEL,      "label",      "color-label" },
1224         { LEGEND,     PUCOL_LEGEND,     "legend",     "color-legend" },
1225         { MISC,       PUCOL_MISC,       "misc",       "color-misc" },
1226         { EDITFIELD,  PUCOL_EDITFIELD,  "editfield",  "color-editfield" },
1227     };
1228
1229     const int numcol = sizeof(pucol) / sizeof(pucol[0]);
1230
1231     for (int i = 0; i < numcol; i++) {
1232         bool dirty = false;
1233         c.clear();
1234         c.setAlpha(1.0);
1235
1236         dirty |= c.merge(_gui->getColor(type + '-' + pucol[i].name));
1237         if (which & pucol[i].mask)
1238             dirty |= c.merge(props->getNode("color"));
1239
1240         if ((pucol[i].mask == LABEL) && !c.isValid())
1241             dirty |= c.merge(_gui->getColor("label"));
1242
1243         dirty |= c.merge(props->getNode(pucol[i].cname));
1244
1245         if (c.isValid() && dirty)
1246             object->setColor(pucol[i].id, c.red(), c.green(), c.blue(), c.alpha());
1247     }
1248 }
1249
1250
1251 static struct {
1252     const char *name;
1253     int key;
1254 } keymap[] = {
1255     {"backspace", 8},
1256     {"tab", 9},
1257     {"return", 13},
1258     {"enter", 13},
1259     {"esc", 27},
1260     {"escape", 27},
1261     {"space", ' '},
1262     {"&amp;", '&'},
1263     {"and", '&'},
1264     {"&lt;", '<'},
1265     {"&gt;", '>'},
1266     {"f1", PU_KEY_F1},
1267     {"f2", PU_KEY_F2},
1268     {"f3", PU_KEY_F3},
1269     {"f4", PU_KEY_F4},
1270     {"f5", PU_KEY_F5},
1271     {"f6", PU_KEY_F6},
1272     {"f7", PU_KEY_F7},
1273     {"f8", PU_KEY_F8},
1274     {"f9", PU_KEY_F9},
1275     {"f10", PU_KEY_F10},
1276     {"f11", PU_KEY_F11},
1277     {"f12", PU_KEY_F12},
1278     {"left", PU_KEY_LEFT},
1279     {"up", PU_KEY_UP},
1280     {"right", PU_KEY_RIGHT},
1281     {"down", PU_KEY_DOWN},
1282     {"pageup", PU_KEY_PAGE_UP},
1283     {"pagedn", PU_KEY_PAGE_DOWN},
1284     {"home", PU_KEY_HOME},
1285     {"end", PU_KEY_END},
1286     {"insert", PU_KEY_INSERT},
1287     {0, -1},
1288 };
1289
1290 int
1291 FGPUIDialog::getKeyCode(const char *str)
1292 {
1293     enum {
1294         CTRL = 0x1,
1295         SHIFT = 0x2,
1296         ALT = 0x4,
1297     };
1298
1299     while (*str == ' ')
1300         str++;
1301
1302     char *buf = new char[strlen(str) + 1];
1303     strcpy(buf, str);
1304     char *s = buf + strlen(buf);
1305     while (s > str && s[-1] == ' ')
1306         s--;
1307     *s = 0;
1308     s = buf;
1309
1310     int mod = 0;
1311     while (1) {
1312         if (!strncmp(s, "Ctrl-", 5) || !strncmp(s, "CTRL-", 5))
1313             s += 5, mod |= CTRL;
1314         else if (!strncmp(s, "Shift-", 6) || !strncmp(s, "SHIFT-", 6))
1315             s += 6, mod |= SHIFT;
1316         else if (!strncmp(s, "Alt-", 4) || !strncmp(s, "ALT-", 4))
1317             s += 4, mod |= ALT;
1318         else
1319             break;
1320     }
1321
1322     int key = -1;
1323     if (strlen(s) == 1 && isascii(*s)) {
1324         key = *s;
1325         if (mod & SHIFT)
1326             key = toupper(key);
1327         if (mod & CTRL)
1328             key = toupper(key) - '@';
1329         /* if (mod & ALT)
1330             ;   // Alt not propagated to the gui
1331         */
1332     } else {
1333         for (char *t = s; *t; t++)
1334             *t = tolower(*t);
1335         for (int i = 0; keymap[i].name; i++) {
1336             if (!strcmp(s, keymap[i].name)) {
1337                 key = keymap[i].key;
1338                 break;
1339             }
1340         }
1341     }
1342     delete[] buf;
1343     return key;
1344 }
1345
1346 void FGPUIDialog::relayout()
1347 {
1348   _needsRelayout = false;
1349
1350   int screenw = globals->get_props()->getIntValue("/sim/startup/xsize");
1351   int screenh = globals->get_props()->getIntValue("/sim/startup/ysize");
1352
1353   bool userx = _props->hasValue("x");
1354   bool usery = _props->hasValue("y");
1355   bool userw = _props->hasValue("width");
1356   bool userh = _props->hasValue("height");
1357
1358   // Let the layout widget work in the same property subtree.
1359   LayoutWidget wid(_props);
1360   wid.setDefaultFont(_font, int(_font->getPointSize()));
1361
1362   int pw = 0, ph = 0;
1363   int px, py, savex, savey;
1364   if (!userw || !userh) {
1365     wid.calcPrefSize(&pw, &ph);
1366   }
1367
1368   pw = _props->getIntValue("width", pw);
1369   ph = _props->getIntValue("height", ph);
1370   px = savex = _props->getIntValue("x", (screenw - pw) / 2);
1371   py = savey = _props->getIntValue("y", (screenh - ph) / 2);
1372
1373   // Negative x/y coordinates are interpreted as distance from the top/right
1374   // corner rather than bottom/left.
1375   if (userx && px < 0)
1376     px = screenw - pw + px;
1377   if (usery && py < 0)
1378     py = screenh - ph + py;
1379
1380   // Define "x", "y", "width" and/or "height" in the property tree if they
1381   // are not specified in the configuration file.
1382   wid.layout(px, py, pw, ph);
1383
1384   applySize(_object);
1385
1386   // Remove automatically generated properties, so the layout looks
1387   // the same next time around, or restore x and y to preserve negative coords.
1388   if (userx)
1389       _props->setIntValue("x", savex);
1390   else
1391       _props->removeChild("x");
1392
1393   if (usery)
1394       _props->setIntValue("y", savey);
1395   else
1396       _props->removeChild("y");
1397
1398   if (!userw) _props->removeChild("width");
1399   if (!userh) _props->removeChild("height");
1400 }
1401
1402 void
1403 FGPUIDialog::applySize(puObject *object)
1404 {
1405   // compound plib widgets use setUserData() for internal purposes, so refuse
1406   // to descend into anything that has other bits set than the following
1407   const int validUserData = PUCLASS_VALUE|PUCLASS_OBJECT|PUCLASS_GROUP|PUCLASS_INTERFACE
1408           |PUCLASS_FRAME|PUCLASS_TEXT|PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
1409           |PUCLASS_ARROW|PUCLASS_DIAL|PUCLASS_POPUP;
1410
1411   int type = object->getType();
1412   if ((type & PUCLASS_GROUP) && !(type & ~validUserData)) {
1413     puObject* c = ((puGroup *)object)->getFirstChild();
1414     for (; c != NULL; c = c->getNextObject()) {
1415       applySize(c);
1416     } // of child iteration
1417   } // of group object case
1418
1419   GUIInfo *info = (GUIInfo *)object->getUserData();
1420   if (!info)
1421     return;
1422
1423   SGPropertyNode *n = info->node;
1424   if (!n) {
1425     SG_LOG(SG_GENERAL, SG_ALERT, "FGDialog::applySize: no props");
1426     return;
1427   }
1428
1429   int x = n->getIntValue("x");
1430   int y = n->getIntValue("y");
1431   int w = n->getIntValue("width", 4);
1432   int h = n->getIntValue("height", 4);
1433   object->setPosition(x, y);
1434   object->setSize(w, h);
1435 }
1436
1437 ////////////////////////////////////////////////////////////////////////
1438 // Implementation of FGDialog::PropertyObject.
1439 ////////////////////////////////////////////////////////////////////////
1440
1441 FGPUIDialog::PropertyObject::PropertyObject(const char *n,
1442         puObject *o, SGPropertyNode_ptr p) :
1443     name(n),
1444     object(o),
1445     node(p)
1446 {
1447 }
1448
1449
1450
1451 ////////////////////////////////////////////////////////////////////////
1452 // Implementation of fgValueList and derived pui widgets
1453 ////////////////////////////////////////////////////////////////////////
1454
1455
1456 fgValueList::fgValueList(SGPropertyNode *p) :
1457     _props(p)
1458 {
1459     make_list();
1460 }
1461
1462 void
1463 fgValueList::update()
1464 {
1465     destroy_list();
1466     make_list();
1467 }
1468
1469 fgValueList::~fgValueList()
1470 {
1471     destroy_list();
1472 }
1473
1474 void
1475 fgValueList::make_list()
1476 {
1477   SGPropertyNode_ptr values = _props;
1478   const char* vname = "value";
1479
1480   if (_props->hasChild("properties")) {
1481     // dynamic values, read from a property's children
1482     const char* path = _props->getStringValue("properties");
1483     values = fgGetNode(path, true);
1484   }
1485
1486   if (_props->hasChild("property-name")) {
1487     vname = _props->getStringValue("property-name");
1488   }
1489
1490   std::vector<SGPropertyNode_ptr> value_nodes = values->getChildren(vname);
1491   _list = new char *[value_nodes.size() + 1];
1492   unsigned int i;
1493   for (i = 0; i < value_nodes.size(); i++) {
1494     _list[i] = strdup((char *)value_nodes[i]->getStringValue());
1495   }
1496   _list[i] = 0;
1497 }
1498
1499 void
1500 fgValueList::destroy_list()
1501 {
1502     for (int i = 0; _list[i] != 0; i++)
1503         if (_list[i])
1504             free(_list[i]);
1505     delete[] _list;
1506 }
1507
1508
1509
1510 void
1511 fgList::update()
1512 {
1513     fgValueList::update();
1514     int top = getTopItem();
1515     newList(_list);
1516     setTopItem(top);
1517 }
1518
1519 ////////////////////////////////////////////////////////////////////////
1520 // Implementation of fgLogList
1521 ////////////////////////////////////////////////////////////////////////
1522
1523 void LogList::update()
1524 {
1525     if (!m_buffer) return;
1526
1527     if (m_stamp != m_buffer->stamp()) {
1528         m_stamp = m_buffer->threadsafeCopy(m_items);
1529         m_items.push_back(NULL); // terminator value
1530         newList((char**) m_items.data());
1531         setTopItem(m_items.size() - 1); // scroll to bottom of list
1532     }
1533 }
1534
1535 void LogList::setBuffer(simgear::BufferedLogCallback* buf)
1536 {
1537     m_buffer = buf;
1538     m_stamp = m_buffer->stamp() - 1; // force an update
1539     update();
1540 }
1541
1542 ////////////////////////////////////////////////////////////////////////
1543 // Implementation of fgComboBox
1544 ////////////////////////////////////////////////////////////////////////
1545
1546
1547 void fgComboBox::update()
1548 {
1549   if (_inHit) {
1550     return;
1551   }
1552
1553   std::string curValue(getStringValue());
1554   fgValueList::update();
1555   newList(_list);
1556   int currentItem = puaComboBox::getCurrentItem();
1557
1558
1559 // look for the previous value, in the new list
1560   for (int i = 0; _list[i] != 0; i++) {
1561     if (_list[i] == curValue) {
1562     // don't set the current item again; this is important to avoid
1563     // recursion here if the combo callback ultimately causes another dialog-update
1564       if (i != currentItem) {
1565         puaComboBox::setCurrentItem(i);
1566       }
1567
1568       return;
1569     }
1570   } // of list values iteration
1571
1572 // cound't find current item, default to first
1573   if (currentItem != 0) {
1574     puaComboBox::setCurrentItem(0);
1575   }
1576 }
1577
1578 int fgComboBox::checkHit(int b, int up, int x, int y)
1579 {
1580   _inHit = true;
1581   int r = puaComboBox::checkHit(b, up, x, y);
1582   _inHit = false;
1583   return r;
1584 }
1585
1586 void fgComboBox::setSize(int w, int h)
1587 {
1588   puaComboBox::setSize(w, h);
1589   recalc_bbox();
1590 }
1591
1592 void fgComboBox::recalc_bbox()
1593 {
1594 // bug-fix for issue #192
1595 // http://code.google.com/p/flightgear-bugs/issues/detail?id=192
1596 // puaComboBox is including the height of its popupMenu in the height
1597 // computation, which breaks layout computations.
1598 // this implementation skips popup-menus
1599
1600   puBox contents;
1601   contents.empty();
1602
1603   for (puObject *bo = dlist; bo != NULL; bo = bo -> getNextObject()) {
1604     if (bo->getType() & PUCLASS_POPUPMENU) {
1605       continue;
1606     }
1607
1608     contents.extend (bo -> getBBox()) ;
1609   }
1610
1611   abox.max[0] = abox.min[0] + contents.max[0] ;
1612   abox.max[1] = abox.min[1] + contents.max[1] ;
1613
1614   puObject::recalc_bbox () ;
1615
1616 }
1617
1618 // end of FGPUIDialog.cxx