Nasal/gui.nas

   1 ##
   2 # Pop up a "tip" dialog for a moment, then remove it.  The delay in
   3 # seconds can be specified as the second argument.  The default is 4
   4 # seconds.  The third argument can be a hash with override values.
   5 # Note that the tip dialog is a shared resource.  If someone else
   6 # comes along and wants to pop a tip up before your delay is finished,
   7 # you lose. :)
   8 #
   9 var popupTip = func(label, delay = nil, override = nil, position = nil)
  10 {
  11     if (position == nil) {
  12         position = {};
  13     }
  14     fgcommand("show-message", props.Node.new({ "label": label, "delay":delay, "x": position['x'], "y": position['y'] }));
  15 }
  16
  17 var showDialog = func(name) {
  18     fgcommand("dialog-show", props.Node.new({ "dialog-name" : name }));
  19 }
  20
  21 ##
  22 # Enable/disable named menu entry
  23 #
  24 var menuEnable = func(searchname, state) {
  25     foreach (var menu; props.globals.getNode("/sim/menubar/default").getChildren("menu")) {
  26         foreach (var name; menu.getChildren("name")) {
  27             if (name.getValue() == searchname) {
  28                 menu.getNode("enabled").setBoolValue(state);
  29             }
  30         }
  31         foreach (var item; menu.getChildren("item")) {
  32             foreach (var name; item.getChildren("name")) {
  33                 if (name.getValue() == searchname) {
  34                     item.getNode("enabled").setBoolValue(state);
  35                 }
  36             }
  37         }
  38     }
  39 }
  40
  41 ##
  42 # Set the binding for a menu item to a Nasal script,
  43 # typically a dialog open() command.
  44 #
  45 var menuBind = func(searchname, command) {
  46     foreach (var menu; props.globals.getNode("/sim/menubar/default").getChildren("menu")) {
  47         foreach (var item; menu.getChildren("item")) {
  48             foreach (var name; item.getChildren("name")) {
  49                 if (name.getValue() == searchname) {
  50                     item.getNode("binding", 1).getNode("command", 1).setValue("nasal");
  51                     item.getNode("binding", 1).getNode("script", 1).setValue(command);
  52                     fgcommand("gui-redraw");
  53                 }
  54             }
  55         }
  56     }
  57 }
  58
  59 ##
  60 # Set mouse cursor coordinates and shape (number or name), and return
  61 # current shape (number).
  62 #
  63 # Example:  var cursor = gui.setCursor();
  64 #           gui.setCursor(nil, nil, "wait");
  65 #
  66 var setCursor = func(x = nil, y = nil, cursor = nil) {
  67     var args = props.Node.new();
  68     if (x != nil) args.getNode("x", 1).setIntValue(x);
  69     if (y != nil) args.getNode("y", 1).setIntValue(y);
  70     if (cursor != nil) {
  71         if (num(cursor) == nil)
  72             cursor = cursor_types[cursor];
  73         if (cursor == nil)
  74             die("cursor must be one of: " ~ string.join(", ", keys(cursor_types)));
  75         setprop("/sim/mouse/hide-cursor", cursor);
  76         args.getNode("cursor", 1).setIntValue(cursor);
  77     }
  78     fgcommand("set-cursor", args);
  79     return args.getValue("cursor");
  80 }
  81
  82 ##
  83 # Supported mouse cursor types.
  84 #
  85 var cursor_types = { none: 0, pointer: 1, wait: 2, crosshair: 3, leftright: 4,
  86     topside: 5, bottomside: 6, leftside: 7, rightside: 8,
  87     topleft: 9, topright: 10, bottomleft: 11, bottomright: 12,
  88 };
  89
  90 ##
  91 # Find a GUI element by given name.
  92 # dialog: dialog root property.
  93 # name: name of GUI element to be searched.
  94 # Returns GUI element when found, nil otherwise.
  95 #
  96 var findElementByName = func(dialog,name) {
  97         foreach( var child; dialog.getChildren() ) {
  98                 var n = child.getNode( "name" );
  99                 if( n != nil and n.getValue() == name )
 100                         return child;
 101                 var f = findElementByName(child, name);
 102                 if( f != nil ) return f;
 103         }
 104         return nil;
 105 };
 106
 107
 108 ########################################################################
 109 # Private Stuff:
 110 ########################################################################
 111
 112 ##
 113 # Initialize property nodes via a timer, to insure the props module is
 114 # loaded.  See notes in view.nas.  Simply cache the screen height
 115 # property and the argument for the "dialog-show" command.  This
 116 # probably isn't really needed...
 117 #
 118 var fdm = getprop("/sim/flight-model");
 119 var screenHProp = nil;
 120 var autopilotDisableProps = [
 121   "/autopilot/hide-menu",
 122   "/autopilot/KAP140/locks",
 123   "/autopilot/CENTURYIIB/locks",
 124   "/autopilot/CENTURYIII/locks"
 125 ];
 126
 127 _setlistener("/sim/signals/nasal-dir-initialized", func {
 128     screenHProp = props.globals.getNode("/sim/startup/ysize");
 129
 130     props.globals.getNode("/sim/help/debug", 1).setValues(debug_keys);
 131     props.globals.getNode("/sim/help/basic", 1).setValues(basic_keys);
 132     props.globals.getNode("/sim/help/common", 1).setValues(common_aircraft_keys);
 133
 134     # enable/disable menu entries
 135     menuEnable("fuel-and-payload", fdm == "yasim" or fdm == "jsb");
 136     menuEnable("aircraft-checklists", props.globals.getNode("/sim/checklists") != nil);
 137     var isAutopilotMenuEnabled = func {
 138       foreach( var apdp; autopilotDisableProps ) {
 139         if( props.globals.getNode( apdp ) != nil )
 140           return 0;
 141       }
 142       return 1;
 143     }
 144     menuEnable("autopilot", isAutopilotMenuEnabled() );
 145     menuEnable("joystick-info", size(props.globals.getNode("/input/joysticks").getChildren("js")));
 146     menuEnable("rendering-buffers", getprop("/sim/rendering/rembrandt/enabled"));
 147     menuEnable("rembrandt-buffers-choice", getprop("/sim/rendering/rembrandt/enabled"));
 148     menuEnable("stereoscopic-options", !getprop("/sim/rendering/rembrandt/enabled"));
 149     menuEnable("sound-config", getprop("/sim/sound/working"));
 150
 151     # frame-per-second display
 152     var fps = props.globals.getNode("/sim/rendering/fps-display", 1);
 153     setlistener(fps, fpsDisplay, 1);
 154     setlistener("/sim/startup/xsize", func {
 155         if (fps.getValue()) {
 156             fpsDisplay(0);
 157             fpsDisplay(1);
 158         }
 159     });
 160
 161     # frame-latency display
 162     var latency = props.globals.getNode("/sim/rendering/frame-latency-display", 1);
 163     setlistener(latency, latencyDisplay, 1);
 164     setlistener("/sim/startup/xsize", func {
 165         if (latency.getValue()) {
 166             latencyDisplay(0);
 167             latencyDisplay(1);
 168         }
 169     });
 170
 171     # only enable precipitation if gui *and* aircraft want it
 172     var p = "/sim/rendering/precipitation-";
 173     var precip_gui = getprop(p ~ "gui-enable");
 174     var precip_ac = getprop(p ~ "aircraft-enable");
 175     props.globals.getNode(p ~ "enable").setAttribute("userarchive", 0); # TODO remove later
 176     var set_precip = func setprop(p ~ "enable", precip_gui and precip_ac);
 177     setlistener(p ~ "gui-enable", func(n) set_precip(precip_gui = n.getValue()),1);
 178     setlistener(p ~ "aircraft-enable", func(n) set_precip(precip_ac = n.getValue()),1);
 179
 180     # the autovisibility feature of the menubar
 181     # automatically show the menubar if the mouse is at the upper edge of the window
 182     # the menubar is hidden by a binding to a LMB click in mode 0 in mice.xml
 183     var menubarAutoVisibilityListener = nil;
 184     var menubarAutoVisibilityEdge = props.globals.initNode( "/sim/menubar/autovisibility/edge-size", 5, "INT" );
 185     var menubarVisibility = props.globals.initNode( "/sim/menubar/visibility", 0, "BOOL" );
 186     var currentMenubarVisibility = menubarVisibility.getValue();
 187     var mouseMode = props.globals.initNode( "/devices/status/mice/mouse/mode", 0, "INT" );
 188
 189     setlistener( "/sim/menubar/autovisibility/enabled", func(n) {
 190       if( n.getValue() and menubarAutoVisibilityListener == nil ) {
 191         currentMenubarVisibility = menubarVisibility.getValue();
 192         menubarVisibility.setBoolValue( 0 );
 193         menubarAutoVisibilityListener = setlistener( "/devices/status/mice/mouse/y", func(n) {
 194           if( n.getValue() == nil ) return;
 195           if( mouseMode.getValue() != 0 ) return;
 196
 197           if(  n.getValue() <= menubarAutoVisibilityEdge.getValue() )
 198             menubarVisibility.setBoolValue( 1 );
 199
 200         }, 1, 0 );
 201       }
 202
 203       # don't listen to the mouse position if this feature is enabled
 204       if( n.getValue() == 0 and menubarAutoVisibilityListener != nil ) {
 205         removelistener( menubarAutoVisibilityListener );
 206         menubarAutoVisibilityListener = nil;
 207         menubarVisibility.setBoolValue(currentMenubarVisibility);
 208       }
 209   }, 1, 0);
 210
 211 });
 212
 213
 214 ##
 215 # Show/hide the fps display dialog.
 216 #
 217 var fpsDisplay = func(n) {
 218     var w = isa(n, props.Node) ? n.getValue() : n;
 219     fgcommand(w ? "dialog-show" : "dialog-close", props.Node.new({"dialog-name": "fps"}));
 220 }
 221 var latencyDisplay = func(n) {
 222     var w = isa(n, props.Node) ? n.getValue() : n;
 223     fgcommand(w ? "dialog-show" : "dialog-close", props.Node.new({"dialog-name": "frame-latency"}));
 224 }
 225
 226 ##
 227 # Pop down the tip dialog, if it is visible.
 228 #
 229 var popdown = func { fgcommand("clear-message", props.Node.new({"id": canvas.tooltip.getTooltipId()})); }
 230
 231 # Marker for the "current" timer.  This value gets stored in the
 232 # closure of the timer function, and is used to check that there
 233 # hasn't been a more recent timer set that should override.
 234 var currTimer = 0;
 235
 236 ########################################################################
 237 # Widgets & Layout Management
 238 ########################################################################
 239
 240 ##
 241 # A "widget" class that wraps a property node.  It provides useful
 242 # helper methods that are difficult or tedious with the raw property
 243 # API.  Note especially the slightly tricky addChild() method.
 244 #
 245 var Widget = {
 246     set : func(name, val) { me.node.getNode(name, 1).setValue(val); },
 247     prop : func { return me.node; },
 248     new : func { return { parents : [Widget], node : props.Node.new() } },
 249     addChild : func(type) {
 250         var idx = size(me.node.getChildren(type));
 251         var name = type ~ "[" ~ idx ~ "]";
 252         var newnode = me.node.getNode(name, 1);
 253         return { parents : [Widget], node : newnode };
 254     },
 255     setColor : func(r, g, b, a = 1) {
 256         me.node.setValues({ color : { red:r, green:g, blue:b, alpha:a } });
 257     },
 258     setFont : func(n, s = 13, t = 0) {
 259         me.node.setValues({ font : { name:n, "size":s, slant:t } });
 260     },
 261     setBinding : func(cmd, carg = nil) {
 262         var idx = size(me.node.getChildren("binding"));
 263         var node = me.node.getChild("binding", idx, 1);
 264         node.getNode("command", 1).setValue(cmd);
 265         if (cmd == "nasal") {
 266             node.getNode("script", 1).setValue(carg);
 267         } elsif (carg != nil and (cmd == "dialog-apply" or cmd == "dialog-update")) {
 268             node.getNode("object-name", 1).setValue(carg);
 269         }
 270     },
 271 };
 272
 273
 274 ##
 275 # Dialog class. Maintains one XML dialog.
 276 #
 277 # SYNOPSIS:
 278 # (B) Dialog.new(<dialog-name>);   ... use dialog from $FG_ROOT/gui/dialogs/
 279 #
 280 # (A) Dialog.new(<prop>, <path> [, <dialog-name>]);
 281 #                                  ... load aircraft specific dialog from
 282 #                                      <path> under property <prop> and under
 283 #                                      name <dialog-name>; if no name is given,
 284 #                                      then it's taken from the XML dialog
 285 #
 286 #         prop        ... target node (name must be "dialog")
 287 #         path        ... file path relative to $FG_ROOT
 288 #         dialog-name ... dialog <name> of dialog in $FG_ROOT/gui/dialogs/
 289 #
 290 # EXAMPLES:
 291 #
 292 #     var dlg = gui.Dialog.new("/sim/gui/dialogs/foo-config/dialog",
 293 #                              "Aircraft/foo/foo_config.xml");
 294 #     dlg.open();
 295 #     dlg.close();
 296 #
 297 #     var livery_dialog = gui.Dialog.new("livery-select");
 298 #     livery_dialog.toggle();
 299 #
 300 var Dialog = {
 301     new: func(prop, path = nil, name = nil) {
 302         var m = { parents: [Dialog] };
 303         m.state = 0;
 304         m.listener = nil;
 305         if (path == nil) { # global dialog in $FG_ROOT/gui/dialogs/
 306             m.name = prop;
 307             m.prop = props.Node.new({ "dialog-name" : prop });
 308         } else {           # aircraft dialog with given path
 309             m.name = name;
 310             m.path = path;
 311             m.prop = isa(prop, props.Node) ? prop : props.globals.getNode(prop, 1);
 312             if (m.prop.getName() != "dialog")
 313                 die("Dialog class: node name must end with '/dialog'");
 314
 315             m.listener = setlistener("/sim/signals/reinit-gui", func m.load(), 1);
 316         }
 317         return Dialog.instance[m.name] = m;
 318     },
 319     del: func
 320     {
 321         if (me.listener != nil)
 322             removelistener(me.listener);
 323     },
 324     # doesn't need to be called explicitly, but can be used to force a reload
 325     load: func {
 326         var state = me.state;
 327         if (state)
 328             me.close();
 329
 330         me.prop.removeChildren();
 331         io.read_properties(me.path, me.prop);
 332
 333         var n = me.prop.getNode("name");
 334         if (n == nil)
 335             die("Dialog class: XML dialog must have <name>");
 336
 337         if (me.name == nil)
 338             me.name = n.getValue();
 339         else
 340             n.setValue(me.name);
 341
 342         me.prop.getNode("dialog-name", 1).setValue(me.name);
 343         fgcommand("dialog-new", me.prop);
 344         if (state)
 345             me.open();
 346     },
 347     # allows access to dialog-embedded Nasal variables/functions
 348     namespace: func {
 349         var ns = "__dlg:" ~ me.name;
 350         me.state and contains(globals, ns) ? globals[ns] : nil;
 351     },
 352     open: func {
 353         fgcommand("dialog-show", me.prop);
 354         me.state = 1;
 355     },
 356     close: func {
 357         fgcommand("dialog-close", me.prop);
 358         me.state = 0;
 359     },
 360     toggle: func {
 361         me.state ? me.close() : me.open();
 362     },
 363     is_open: func {
 364         me.state;
 365     },
 366     instance: {},
 367 };
 368
 369
 370 ##
 371 # Overlay selector. Displays a list of overlay XML files and copies the
 372 # chosen one to the property tree. The class allows to select liveries,
 373 # insignia, decals, variants, etc. Usually the overlay properties are
 374 # fed to "select" and "material" animations.
 375 #
 376 # SYNOPSIS:
 377 #       OverlaySelector.new(<title>, <dir>, <nameprop> [, <sortprop> [, <mpprop> [, <callback>]]]);
 378 #
 379 #       title    ... dialog title
 380 #       dir      ... directory where to find the XML overlay files,
 381 #                    relative to FG_ROOT
 382 #       nameprop ... property in an overlay file that contains the name
 383 #                    The result is written to this place in the
 384 #                    property tree.
 385 #       sortprop ... property in an overlay file that should be used
 386 #                    as sorting criterion, if alphabetic sorting by
 387 #                    name is undesirable. Use nil if you don't need
 388 #                    this, but want to set a callback function.
 389 #       mpprop   ... property path of MP node where the file name should
 390 #                    be written to
 391 #       callback ... function that's called after a new entry was chosen,
 392 #                    with these arguments:
 393 #
 394 #                    callback(<number>, <name>, <sort-criterion>, <file>,  <path>)
 395 #
 396 # EXAMPLE:
 397 #       aircraft.data.add("sim/model/pilot");  # autosave the pilot
 398 #       var pilots_dialog = gui.OverlaySelector.new("Pilots",
 399 #               "Aircraft/foo/Models/Pilots",
 400 #               "sim/model/pilot");
 401 #
 402 #       pilots_dialog.open();  # or ... close(), or toggle()
 403 #
 404 #
 405 var OverlaySelector = {
 406     new: func(title, dir, nameprop, sortprop = nil, mpprop = nil, callback = nil) {
 407         var name = "overlay-select-";
 408         var data = props.globals.getNode("/sim/gui/dialogs/", 1);
 409         for (var i = 1; 1; i += 1)
 410             if (data.getNode(name ~ i, 0) == nil)
 411                 break;
 412         data = data.getNode(name ~= i, 1);
 413
 414         var m = Dialog.new(data.getNode("dialog", 1), "gui/dialogs/overlay-select.xml", name);
 415         m.parents = [OverlaySelector, Dialog];
 416
 417         # resolve the path in FG_ROOT, and --fg-aircraft dir, etc
 418         m.dir = resolvepath(dir) ~ "/";
 419
 420         var relpath = func(p) substr(p, p[0] == `/`);
 421         m.nameprop = relpath(nameprop);
 422         m.sortprop = relpath(sortprop or nameprop);
 423         m.mpprop = mpprop;
 424         m.callback = callback;
 425         m.title = title;
 426         m.dialog_name = name;
 427         m.result = data.initNode("result", "");
 428         m.listener = setlistener(m.result, func(n) m.select(n.getValue()));
 429         if (m.mpprop != nil)
 430             aircraft.data.add(m.nameprop);
 431         m.reinit();
 432         # need to reinit again, whenever the GUI is reloaded
 433         m.reinit_listener = setlistener("/sim/signals/reinit-gui", func(n) m.reinit());
 434         return m;
 435     },
 436     reinit: func {
 437         me.prop.getNode("group/text/label").setValue(me.title);
 438         me.prop.getNode("group/button/binding/script").setValue('gui.Dialog.instance["' ~ me.dialog_name ~ '"].close()');
 439         me.list = me.prop.getNode("list");
 440         me.list.getNode("property").setValue(me.result.getPath());
 441         me.rescan();
 442         me.current = -1;
 443         me.select(getprop(me.nameprop) or "");
 444     },
 445     del: func {
 446         removelistener(me.listener);
 447         removelistener(me.reinit_listener);
 448         # call inherited 'del'
 449         me.parents = subvec(me.parents,1);
 450         me.del();
 451     },
 452     rescan: func {
 453         me.data = [];
 454         var files = directory(me.dir);
 455         if (size(files)) {
 456             foreach (var file; files) {
 457                 if (substr(file, -4) != ".xml")
 458                     continue;
 459                 var n = io.read_properties(me.dir ~ file);
 460                 var name = n.getNode(me.nameprop, 1).getValue();
 461                 var index = n.getNode(me.sortprop, 1).getValue();
 462                 if (name == nil or index == nil)
 463                     continue;
 464                 append(me.data, [name, index, substr(file, 0, size(file) - 4), me.dir ~ file]);
 465             }
 466             me.data = sort(me.data, func(a, b) num(a[1]) == nil or num(b[1]) == nil
 467                     ? cmp(a[1], b[1]) : a[1] - b[1]);
 468         }
 469
 470         me.list.removeChildren("value");
 471         forindex (var i; me.data)
 472             me.list.getChild("value", i, 1).setValue(me.data[i][0]);
 473     },
 474     set: func(index) {
 475         var last = me.current;
 476         me.current = math.mod(index, size(me.data));
 477         io.read_properties(me.data[me.current][3], props.globals);
 478         if (last != me.current and me.callback != nil)
 479             call(me.callback, [me.current] ~ me.data[me.current], me);
 480         if (me.mpprop != nil)
 481             setprop(me.mpprop, me.data[me.current][2]);
 482     },
 483     select: func(name) {
 484         forindex (var i; me.data)
 485             if (me.data[i][0] == name)
 486                 me.set(i);
 487     },
 488     next: func {
 489         me.set(me.current + 1);
 490     },
 491     previous: func {
 492         me.set(me.current - 1);
 493     },
 494 };
 495
 496
 497 ##
 498 # FileSelector class (derived from Dialog class).
 499 #
 500 # SYNOPSIS: FileSelector.new(<callback>, <title>, <button> [, <pattern> [, <dir> [, <file> [, <dotfiles>]]]])
 501 #
 502 #         callback ... callback function that gets return value as first argument
 503 #         title    ... dialog title
 504 #         button   ... button text (should say "Save", "Load", etc. and not just "OK")
 505 #         pattern  ... array with shell pattern or nil (which is equivalent to "*")
 506 #         dir      ... starting dir ($FG_ROOT if unset)
 507 #         file     ... pre-selected default file name
 508 #         dotfiles ... flag that decides whether UNIX dotfiles should be shown (1) or not (0)
 509 #
 510 # EXAMPLE:
 511 #
 512 #     var report = func(n) { print("file ", n.getValue(), " selected") }
 513 #     var selector = gui.FileSelector.new(
 514 #             report,                 # callback function
 515 #             "Save Flight",          # dialog title
 516 #             "Save",                 # button text
 517 #             ["*.sav", "*.xml"],     # pattern for displayed files
 518 #             "/tmp",                 # start dir
 519 #             "flight.sav");          # default file name
 520 #     selector.open();
 521 #
 522 #     selector.close();
 523 #     selector.set_title("Save Another Flight");
 524 #     selector.open();
 525 #
 526 var FileSelector = {
 527     new: func(callback, title, button, pattern = nil, dir = "", file = "", dotfiles = 0, show_files=1) {
 528
 529
 530         var usage = gui.FILE_DIALOG_OPEN_FILE;
 531         if (!show_files) {
 532             usage = gui.FILE_DIALOG_CHOOSE_DIR;
 533         } else if (button == 'Save') {
 534             # nasty, should make this explicit
 535             usage = gui.FILE_DIALOG_SAVE_FILE;
 536         }
 537
 538         m = { parents:[FileSelector],
 539              _inner: gui._createFileDialog(usage)};
 540
 541         m.set_title(title);
 542         m.set_button(button);
 543         m.set_directory(dir);
 544         m.set_file(file);
 545         m.set_dotfiles(dotfiles);
 546         m.set_pattern(pattern);
 547
 548         m._inner.setCallback(func (path) {
 549             var node = props.Node.new();
 550             node.setValue(path);
 551             callback(node);
 552         }   );
 553
 554         return m;
 555     },
 556     # setters only take effect after the next call to open()
 557     set_title: func(title) { me._inner.title = title },
 558     set_button: func(button) { me._inner.button = button },
 559     set_directory: func(dir) { me._inner.directory = directory },
 560     set_file: func(file) { me._inner.placeholder = file },
 561     set_dotfiles: func(dot) { me._inner.show_hidden = dot },
 562     set_pattern: func(pattern) { me._inner.pattern = (pattern == nil) ? [] : pattern },
 563
 564     open: func() { me._inner.open(); },
 565     close: func() { me._inner.close(); },
 566
 567     del: func {
 568         me._inner.close();
 569         me._inner = nil;
 570     },
 571 };
 572
 573 ##
 574 # DirSelector - convenience "class" (indeed using a reconfigured FileSelector)
 575 #
 576 var DirSelector = {
 577   new: func(callback, title, button, dir = "") {
 578      return FileSelector.new(callback, title, button, nil, dir, "", 0, 0);
 579   }
 580 };
 581
 582 ##
 583 # Save/load flight menu functions.
 584 #
 585 var save_flight_sel = nil;
 586 var save_flight = func {
 587     foreach (var n; props.globals.getNode("/sim/presets").getChildren())
 588         n.setAttribute("archive", 1);
 589     var save = func(n) fgcommand("save", props.Node.new({ file: n.getValue() }));
 590     if (save_flight_sel == nil)
 591         save_flight_sel = FileSelector.new(save, "Save Flight", "Save",
 592                 ["*.sav"], getprop("/sim/fg-home"), "flight.sav");
 593     save_flight_sel.open();
 594 }
 595
 596
 597 var load_flight_sel = nil;
 598 var load_flight = func {
 599     var load = func(n) {
 600         fgcommand("load", props.Node.new({ file: n.getValue() }));
 601         fgcommand("reposition");
 602     }
 603     if (load_flight_sel == nil)
 604         load_flight_sel = FileSelector.new(load, "Load Flight", "Load",
 605                 ["*.sav"], getprop("/sim/fg-home"), "flight.sav");
 606     load_flight_sel.open();
 607 }
 608
 609 ##
 610 # Screen-shot directory menu function
 611 #
 612 var set_screenshotdir_sel = nil;
 613 var set_screenshotdir = func {
 614     if (set_screenshotdir_sel == nil)
 615         set_screenshotdir_sel = gui.DirSelector.new(
 616             func(result) { setprop("/sim/paths/screenshot-dir", result.getValue()); },
 617             "Select Screenshot Directory", "Ok", getprop("/sim/paths/screenshot-dir"));
 618     set_screenshotdir_sel.open();
 619 }
 620
 621 ##
 622 # Open property browser with given target path.
 623 #
 624 var property_browser = func(dir = nil) {
 625     if (dir == nil)
 626         dir = "/";
 627     elsif (isa(dir, props.Node))
 628         dir = dir.getPath();
 629     var dlgname = "property-browser";
 630     foreach (var module; keys(globals))
 631         if (find("__dlg:" ~ dlgname, module) == 0)
 632             return globals[module].clone(dir);
 633
 634     setprop("/sim/gui/dialogs/" ~ dlgname ~ "/last", dir);
 635     fgcommand("dialog-show", props.Node.new({"dialog-name": dlgname}));
 636 }
 637
 638
 639 ##
 640 # Open one property browser per /browser[] property, where each contains
 641 # the target path. On the command line use  --prop:browser=orientation
 642 #
 643 settimer(func {
 644     foreach (var b; props.globals.getChildren("browser"))
 645         if ((var browser = b.getValue()) != nil)
 646             foreach (var path; split(",", browser))
 647                 if (size(path))
 648                     property_browser(string.trim(path));
 649
 650     props.globals.removeChildren("browser");
 651 }, 0);
 652
 653
 654 ##
 655 # Apply whole dialog or list of widgets. This copies the widgets'
 656 # visible contents to the respective <property>.
 657 #
 658 var dialog_apply = func(dialog, objects...) {
 659     var n = props.Node.new({ "dialog-name": dialog });
 660     if (!size(objects))
 661         return fgcommand("dialog-apply", n);
 662
 663     var name = n.getNode("object-name", 1);
 664     foreach (var o; objects) {
 665         name.setValue(o);
 666         fgcommand("dialog-apply", n);
 667     }
 668 }
 669
 670
 671 ##
 672 # Update whole dialog or list of widgets. This makes the widgets
 673 # adopt and display the value of their <property>.
 674 #
 675 var dialog_update = func(dialog, objects...) {
 676     var n = props.Node.new({ "dialog-name": dialog });
 677     if (!size(objects))
 678         return fgcommand("dialog-update", n);
 679
 680     var name = n.getNode("object-name", 1);
 681     foreach (var o; objects) {
 682         name.setValue(o);
 683         fgcommand("dialog-update", n);
 684     }
 685 }
 686
 687
 688 ##
 689 # Searches a dialog tree for widgets with a particular <name> entry and
 690 # sets their <enabled> flag.
 691 #
 692 var enable_widgets = func(node, name, enable = 1) {
 693     foreach (var n; node.getChildren())
 694         enable_widgets(n, name, enable);
 695     if ((var n = node.getNode("name")) != nil and n.getValue() == name)
 696         node.getNode("enabled", 1).setBoolValue(enable);
 697 }
 698
 699
 700
 701 ########################################################################
 702 # GUI theming
 703 ########################################################################
 704
 705 var nextStyle = func {
 706     var curr = getprop("/sim/gui/current-style");
 707     var styles = props.globals.getNode("/sim/gui").getChildren("style");
 708     forindex (var i; styles)
 709         if (styles[i].getIndex() == curr)
 710             break;
 711     if ((i += 1) >= size(styles))
 712         i = 0;
 713     setprop("/sim/gui/current-style", styles[i].getIndex());
 714     fgcommand("gui-redraw");
 715 }
 716
 717
 718 ########################################################################
 719 # Dialog Boxes
 720 ########################################################################
 721
 722 var dialog = {};
 723
 724 var setWeight = func(wgt, opt) {
 725     var lbs = opt.getNode("lbs", 1).getValue();
 726     wgt.getNode("weight-lb", 1).setValue(lbs);
 727
 728     # Weights can have "tank" indices which set the capacity of the
 729     # corresponding tank.  This code should probably be moved to
 730     # something like fuel.setTankCap(tank, gals)...
 731     if(wgt.getNode("tank",0) == nil) { return 0; }
 732     var ti = wgt.getNode("tank").getValue();
 733     var gn = opt.getNode("gals");
 734     var gals = gn == nil ? 0 : gn.getValue();
 735     var tn = props.globals.getNode("consumables/fuel/tank["~ti~"]", 1);
 736     var ppg = tn.getNode("density-ppg", 1).getValue();
 737     var lbs = gals * ppg;
 738     var curr = tn.getNode("level-gal_us", 1).getValue();
 739     curr = curr > gals ? gals : curr;
 740     tn.getNode("capacity-gal_us", 1).setValue(gals);
 741     tn.getNode("level-gal_us", 1).setValue(curr);
 742     tn.getNode("level-lbs", 1).setValue(curr * ppg);
 743     return 1;
 744 }
 745
 746 # Checks the /sim/weight[n]/{selected|opt} values and sets the
 747 # appropriate weights therefrom.
 748 var setWeightOpts = func {
 749     var tankchange = 0;
 750     foreach(var w; props.globals.getNode("sim").getChildren("weight")) {
 751         var selected = w.getNode("selected");
 752         if(selected != nil) {
 753             foreach(var opt; w.getChildren("opt")) {
 754                 if(opt.getNode("name", 1).getValue() == selected.getValue()) {
 755                     if(setWeight(w, opt)) { tankchange = 1; }
 756                     break;
 757                 }
 758             }
 759         }
 760     }
 761     return tankchange;
 762 }
 763 # Run it at startup and on reset to make sure the tank settings are correct
 764 _setlistener("/sim/signals/fdm-initialized", func { settimer(setWeightOpts, 0) });
 765 _setlistener("/sim/signals/reinit", func(n) { props._getValue(n, []) or setWeightOpts() });
 766
 767
 768 # Called from the F&W dialog when the user selects a weight option
 769 var weightChangeHandler = func {
 770     var tankchanged = setWeightOpts();
 771
 772     # This is unfortunate.  Changing tanks means that the list of
 773     # tanks selected and their slider bounds must change, but our GUI
 774     # isn't dynamic in that way.  The only way to get the changes on
 775     # screen is to pop it down and recreate it.
 776     if(tankchanged) {
 777         var p = props.Node.new({"dialog-name": "WeightAndFuel"});
 778         fgcommand("dialog-close", p);
 779         showWeightDialog();
 780     }
 781 }
 782
 783
 784
 785 ##
 786 # Dynamically generates a weight & fuel configuration dialog specific to
 787 # the aircraft.
 788 #
 789 var showWeightDialog = func {
 790     var name = "WeightAndFuel";
 791 #   menu entry is "Fuel and Payload"
 792     var title = "Fuel and Payload Settings";
 793
 794     #
 795     # General Dialog Structure
 796     #
 797     dialog[name] = Widget.new();
 798     dialog[name].set("name", name);
 799     dialog[name].set("layout", "vbox");
 800
 801     var header = dialog[name].addChild("group");
 802     header.set("layout", "hbox");
 803     header.addChild("empty").set("stretch", "1");
 804     header.addChild("text").set("label", title);
 805     header.addChild("empty").set("stretch", "1");
 806     var w = header.addChild("button");
 807     w.set("pref-width", 16);
 808     w.set("pref-height", 16);
 809     w.set("legend", "");
 810     w.set("default", 0);
 811     # "Esc" causes dialog-close
 812     w.set("key", "Esc");
 813     w.setBinding("dialog-close");
 814
 815     dialog[name].addChild("hrule");
 816
 817     if (fdm != "yasim" and fdm != "jsb") {
 818         var msg = dialog[name].addChild("text");
 819         msg.set("label", "Not supported for this aircraft");
 820         var cancel = dialog[name].addChild("button");
 821         cancel.set("key", "Esc");
 822         cancel.set("legend", "Cancel");
 823         cancel.setBinding("dialog-close");
 824         fgcommand("dialog-new", dialog[name].prop());
 825         showDialog(name);
 826         return;
 827     }
 828
 829     # FDM dependent settings
 830     if(fdm == "yasim") {
 831         var fdmdata = {
 832             grosswgt : "/yasim/gross-weight-lbs",
 833             payload  : "/sim",
 834             cg       : nil,
 835         };
 836     } elsif(fdm == "jsb") {
 837         var fdmdata = {
 838             grosswgt : "/fdm/jsbsim/inertia/weight-lbs",
 839             payload  : "/payload",
 840             cg       : "/fdm/jsbsim/inertia/cg-x-in",
 841         };
 842     }
 843
 844     var contentArea = dialog[name].addChild("group");
 845     contentArea.set("layout", "hbox");
 846     contentArea.set("default-padding", 10);
 847
 848     dialog[name].addChild("empty");
 849
 850     var limits = dialog[name].addChild("group");
 851     limits.set("layout", "table");
 852     limits.set("halign", "center");
 853     var row = 0;
 854
 855     var massLimits = props.globals.getNode("/limits/mass-and-balance");
 856
 857     var tablerow = func(name, node, format ) {
 858
 859         var n = isa( node, props.Node ) ? node : massLimits.getNode( node );
 860         if( n == nil ) return;
 861
 862         var label = limits.addChild("text");
 863         label.set("row", row);
 864         label.set("col", 0);
 865         label.set("halign", "right");
 866         label.set("label", name ~ ":");
 867
 868         var val = limits.addChild("text");
 869         val.set("row", row);
 870         val.set("col", 1);
 871         val.set("halign", "left");
 872         val.set("label", "0123457890123456789");
 873         val.set("format", format);
 874         val.set("property", n.getPath());
 875         val.set("live", 1);
 876
 877         row += 1;
 878     }
 879
 880     var grossWgt = props.globals.getNode(fdmdata.grosswgt);
 881     if(grossWgt != nil) {
 882         tablerow("Gross Weight", grossWgt, "%.0f lb");
 883     }
 884
 885     if(massLimits != nil ) {
 886         tablerow("Max. Ramp Weight", "maximum-ramp-mass-lbs", "%.0f lb" );
 887         tablerow("Max. Takeoff  Weight", "maximum-takeoff-mass-lbs", "%.0f lb" );
 888         tablerow("Max. Landing  Weight", "maximum-landing-mass-lbs", "%.0f lb" );
 889         tablerow("Max. Arrested Landing  Weight", "maximum-arrested-landing-mass-lbs", "%.0f lb" );
 890         tablerow("Max. Zero Fuel Weight", "maximum-zero-fuel-mass-lbs", "%.0f lb" );
 891     }
 892
 893     if( fdmdata.cg != nil ) {
 894         var n = props.globals.getNode("/limits/mass-and-balance/cg/dimension");
 895         tablerow("Center of Gravity", props.globals.getNode(fdmdata.cg), "%.1f " ~ (n == nil ? "in" : n.getValue()));
 896     }
 897
 898     dialog[name].addChild("hrule");
 899
 900     var buttonBar = dialog[name].addChild("group");
 901     buttonBar.set("layout", "hbox");
 902     buttonBar.set("default-padding", 10);
 903
 904     var close = buttonBar.addChild("button");
 905     close.set("legend", "Close");
 906     close.set("default", "true");
 907     close.set("key", "Enter");
 908     close.setBinding("dialog-close");
 909
 910     # Temporary helper function
 911     var tcell = func(parent, type, row, col) {
 912         var cell = parent.addChild(type);
 913         cell.set("row", row);
 914         cell.set("col", col);
 915         return cell;
 916     }
 917
 918     #
 919     # Fill in the content area
 920     #
 921     var fuelArea = contentArea.addChild("group");
 922     fuelArea.set("layout", "vbox");
 923     fuelArea.addChild("text").set("label", "Fuel Tanks");
 924
 925     var fuelTable = fuelArea.addChild("group");
 926     fuelTable.set("layout", "table");
 927
 928     fuelArea.addChild("empty").set("stretch", 1);
 929
 930     tcell(fuelTable, "text", 0, 0).set("label", "Tank");
 931     tcell(fuelTable, "text", 0, 3).set("label", "Pounds");
 932     tcell(fuelTable, "text", 0, 4).set("label", "Gallons");
 933     tcell(fuelTable, "text", 0, 5).set("label", "Fraction");
 934
 935     var tanks = props.globals.getNode("/consumables/fuel").getChildren("tank");
 936     for(var i=0; i<size(tanks); i+=1) {
 937         var t = tanks[i];
 938         var hidden=0;
 939         var tname = i ~ "";
 940         var hnode = t.getNode("hidden");
 941         if(hnode != nil) { hidden = hnode.getValue(); }# Check for <hidden> property ,skip adding tank if true#
 942         if(!hidden){
 943         var tnode = t.getNode("name");
 944         if(tnode != nil) { tname = tnode.getValue(); }
 945
 946         var tankprop = "/consumables/fuel/tank["~i~"]";
 947
 948         var cap = t.getNode("capacity-gal_us", 0);
 949
 950         # Hack, to ignore the "ghost" tanks created by the C++ code.
 951         if(cap == nil ) { continue; }
 952         cap = cap.getValue();
 953
 954         # Ignore tanks of capacity 0
 955         if (cap == 0) { continue; }
 956
 957         var title = tcell(fuelTable, "text", i+1, 0);
 958         title.set("label", tname);
 959         title.set("halign", "right");
 960
 961         var selected = props.globals.initNode(tankprop ~ "/selected", 1, "BOOL");
 962         if (selected.getAttribute("writable")) {
 963             var sel = tcell(fuelTable, "checkbox", i+1, 1);
 964             sel.set("property", tankprop ~ "/selected");
 965             sel.set("live", 1);
 966             sel.setBinding("dialog-apply");
 967         }
 968
 969         var slider = tcell(fuelTable, "slider", i+1, 2);
 970         slider.set("property", tankprop ~ "/level-gal_us");
 971         slider.set("live", 1);
 972         slider.set("min", 0);
 973         slider.set("max", cap);
 974         slider.setBinding("dialog-apply");
 975
 976         var lbs = tcell(fuelTable, "text", i+1, 3);
 977         lbs.set("property", tankprop ~ "/level-lbs");
 978         lbs.set("label", "0123456");
 979         lbs.set("format", cap < 1 ? "%.3f" : cap < 10 ? "%.2f" : "%.1f" );
 980         lbs.set("halign", "right");
 981         lbs.set("live", 1);
 982
 983         var gals = tcell(fuelTable, "text", i+1, 4);
 984         gals.set("property", tankprop ~ "/level-gal_us");
 985         gals.set("label", "0123456");
 986         gals.set("format", cap < 1 ? "%.3f" : cap < 10 ? "%.2f" : "%.1f" );
 987         gals.set("halign", "right");
 988         gals.set("live", 1);
 989
 990         var per = tcell(fuelTable, "text", i+1, 5);
 991         per.set("property", tankprop ~ "/level-norm");
 992         per.set("label", "0123456");
 993         per.set("format", "%.2f");
 994         per.set("halign", "right");
 995         per.set("live", 1);
 996         }
 997     }
 998
 999     varbar = tcell(fuelTable, "hrule", size(tanks)+1, 0);
1000     varbar.set("colspan", 6);
1001
1002     var total_label = tcell(fuelTable, "text", size(tanks)+2, 2);
1003     total_label.set("label", "Total:");
1004     total_label.set("halign", "right");
1005
1006     var lbs = tcell(fuelTable, "text", size(tanks)+2, 3);
1007     lbs.set("property", "/consumables/fuel/total-fuel-lbs");
1008     lbs.set("label", "0123456");
1009     lbs.set("format", "%.1f" );
1010     lbs.set("halign", "right");
1011     lbs.set("live", 1);
1012
1013     var gals = tcell(fuelTable, "text",size(tanks) +2, 4);
1014     gals.set("property", "/consumables/fuel/total-fuel-gal_us");
1015     gals.set("label", "0123456");
1016     gals.set("format", "%.1f" );
1017     gals.set("halign", "right");
1018     gals.set("live", 1);
1019
1020     var per = tcell(fuelTable, "text", size(tanks)+2, 5);
1021     per.set("property", "/consumables/fuel/total-fuel-norm");
1022     per.set("label", "0123456");
1023     per.set("format", "%.2f");
1024     per.set("halign", "right");
1025     per.set("live", 1);
1026
1027     var weightArea = contentArea.addChild("group");
1028     weightArea.set("layout", "vbox");
1029     weightArea.addChild("text").set("label", "Payload");
1030
1031     var weightTable = weightArea.addChild("group");
1032     weightTable.set("layout", "table");
1033
1034     weightArea.addChild("empty").set("stretch", 1);
1035
1036     tcell(weightTable, "text", 0, 0).set("label", "Location");
1037     tcell(weightTable, "text", 0, 2).set("label", "Pounds");
1038
1039     var payload_base = props.globals.getNode(fdmdata.payload);
1040     if (payload_base != nil)
1041         var wgts = payload_base.getChildren("weight");
1042     else
1043         var wgts = [];
1044     for(var i=0; i<size(wgts); i+=1) {
1045         var w = wgts[i];
1046         var wname = w.getNode("name", 1).getValue();
1047         var wprop = fdmdata.payload ~ "/weight[" ~ i ~ "]";
1048
1049         var title = tcell(weightTable, "text", i+1, 0);
1050         title.set("label", wname);
1051         title.set("halign", "right");
1052
1053         if(w.getNode("opt") != nil) {
1054             var combo = tcell(weightTable, "combo", i+1, 1);
1055             combo.set("property", wprop ~ "/selected");
1056             combo.set("pref-width", 300);
1057
1058             # Simple code we'd like to use:
1059             #foreach(opt; w.getChildren("opt")) {
1060             #    var ent = combo.addChild("value");
1061             #    ent.prop().setValue(opt.getNode("name", 1).getValue());
1062             #}
1063
1064             # More complicated workaround to move the "current" item
1065             # into the first slot, because dialog.cxx doesn't set the
1066             # selected item in the combo box.
1067             var opts = [];
1068             var curr = w.getNode("selected");
1069             curr = curr == nil ? "" : curr.getValue();
1070             foreach(opt; w.getChildren("opt")) {
1071                 append(opts, opt.getNode("name", 1).getValue());
1072             }
1073             forindex(oi; opts) {
1074                 if(opts[oi] == curr) {
1075                     var tmp = opts[0];
1076                     opts[0] = opts[oi];
1077                     opts[oi] = tmp;
1078                     break;
1079                 }
1080             }
1081             foreach(opt; opts) {
1082                 combo.addChild("value").prop().setValue(opt);
1083             }
1084
1085             combo.setBinding("dialog-apply");
1086             combo.setBinding("nasal", "gui.weightChangeHandler()");
1087         } else {
1088             var slider = tcell(weightTable, "slider", i+1, 1);
1089             slider.set("property", wprop ~ "/weight-lb");
1090             var min = w.getNode("min-lb", 1).getValue();
1091             var max = w.getNode("max-lb", 1).getValue();
1092             slider.set("min", min != nil ? min : 0);
1093             slider.set("max", max != nil ? max : 100);
1094             slider.set("live", 1);
1095             slider.setBinding("dialog-apply");
1096         }
1097
1098         var lbs = tcell(weightTable, "text", i+1, 2);
1099         lbs.set("property", wprop ~ "/weight-lb");
1100         lbs.set("label", "0123456");
1101         lbs.set("format", "%.0f");
1102         lbs.set("live", 1);
1103     }
1104
1105     # All done: pop it up
1106     fgcommand("dialog-new", dialog[name].prop());
1107     showDialog(name);
1108 }
1109
1110
1111
1112
1113 ##
1114 # Dynamically generates a dialog from a help node.
1115 #
1116 # gui.showHelpDialog([<path> [, toggle]])
1117 #
1118 # path   ... path to help node
1119 # toggle ... decides if an already open dialog should be closed
1120 #            (useful when calling the dialog from a key binding; default: 0)
1121 #
1122 # help node
1123 # =========
1124 # each of <title>, <key>, <line>, <text> is optional; uses
1125 # "/sim/description" or "/sim/aircraft" if <title> is omitted;
1126 # only the first <text> is displayed
1127 #
1128 #
1129 # <help>
1130 #     <title>dialog title<title>
1131 #     <key>
1132 #         <name>g/G</name>
1133 #         <desc>gear up/down</desc>
1134 #     </key>
1135 #
1136 #     <line>one line</line>
1137 #     <line>another line</line>
1138 #
1139 #     <text>text in
1140 #           scrollable widget
1141 #     </text>
1142 # </help>
1143 #
1144 var showHelpDialog = func(path, toggle=0) {
1145     var node = props.globals.getNode(path);
1146     if (path == "/sim/help" and size(node.getChildren()) < 4) {
1147         node = node.getChild("common");
1148     }
1149
1150     var name = node.getNode("title", 1).getValue();
1151     if (name == nil) {
1152         name = getprop("/sim/description");
1153         if (name == nil) {
1154             name = getprop("/sim/aircraft");
1155         }
1156     }
1157     var toggle = toggle > 0;
1158     if (toggle and contains(dialog, name)) {
1159         fgcommand("dialog-close", props.Node.new({ "dialog-name": name }));
1160         delete(dialog, name);
1161         return;
1162     }
1163
1164     dialog[name] = Widget.new();
1165     dialog[name].set("layout", "vbox");
1166     dialog[name].set("default-padding", 0);
1167     dialog[name].set("name", name);
1168
1169     # title bar
1170     var titlebar = dialog[name].addChild("group");
1171     titlebar.set("layout", "hbox");
1172     titlebar.addChild("empty").set("stretch", 1);
1173     titlebar.addChild("text").set("label", name);
1174     titlebar.addChild("empty").set("stretch", 1);
1175
1176     var w = titlebar.addChild("button");
1177     w.set("pref-width", 16);
1178     w.set("pref-height", 16);
1179     w.set("legend", "");
1180     w.set("default", 1);
1181     w.set("key", "esc");
1182     w.setBinding("nasal", "delete(gui.dialog, \"" ~ name ~ "\")");
1183     w.setBinding("dialog-close");
1184
1185     dialog[name].addChild("hrule");
1186
1187     # key list
1188     var keylist = dialog[name].addChild("group");
1189     keylist.set("layout", "table");
1190     keylist.set("default-padding", 2);
1191     var keydefs = node.getChildren("key");
1192     var n = size(keydefs);
1193     var row = var col = 0;
1194     foreach (var key; keydefs) {
1195         if (n >= 60 and row >= n / 3 or n >= 16 and row >= n / 2) {
1196             col += 1;
1197             row = 0;
1198         }
1199
1200         var w = keylist.addChild("text");
1201         w.set("row", row);
1202         w.set("col", 2 * col);
1203         w.set("halign", "right");
1204         w.set("label", " " ~ key.getNode("name").getValue());
1205
1206         w = keylist.addChild("text");
1207         w.set("row", row);
1208         w.set("col", 2 * col + 1);
1209         w.set("halign", "left");
1210         w.set("label", "... " ~ key.getNode("desc").getValue() ~ "  ");
1211         row += 1;
1212     }
1213
1214     # separate lines
1215     var lines = node.getChildren("line");
1216     if (size(lines)) {
1217         if (size(keydefs)) {
1218             dialog[name].addChild("empty").set("pref-height", 4);
1219             dialog[name].addChild("hrule");
1220             dialog[name].addChild("empty").set("pref-height", 4);
1221         }
1222
1223         var g = dialog[name].addChild("group");
1224         g.set("layout", "vbox");
1225         g.set("default-padding", 1);
1226         foreach (var lin; lines) {
1227             foreach (var l; split("\n", lin.getValue())) {
1228                 var w = g.addChild("text");
1229                 w.set("halign", "left");
1230                 w.set("label", " " ~ l ~ " ");
1231             }
1232         }
1233     }
1234
1235     # scrollable text area
1236     if (node.getNode("text") != nil) {
1237         dialog[name].set("resizable", 1);
1238         dialog[name].addChild("empty").set("pref-height", 10);
1239
1240         var width = [640, 800, 1152][col];
1241         var height = screenHProp.getValue() - (100 + (size(keydefs) / (col + 1) + size(lines)) * 28);
1242         if (height < 200) {
1243             height = 200;
1244         }
1245
1246         var w = dialog[name].addChild("textbox");
1247         w.set("padding", 4);
1248         w.set("halign", "fill");
1249         w.set("valign", "fill");
1250         w.set("stretch", "true");
1251         w.set("slider", 20);
1252         w.set("pref-width", width);
1253         w.set("pref-height", height);
1254         w.set("editable", 0);
1255         w.set("property", node.getPath() ~ "/text");
1256     } else {
1257         dialog[name].addChild("empty").set("pref-height", 8);
1258     }
1259     fgcommand("dialog-new", dialog[name].prop());
1260     showDialog(name);
1261 }
1262
1263
1264 var debug_keys = {
1265     title: "Development Keys",
1266     key: [
1267        #{ name: "Ctrl-U",    desc: "add 1000 ft of emergency altitude" },
1268         { name: "Shift-F3",  desc: "load panel" },
1269         { name: "/",         desc: "open property browser" },
1270     ],
1271 };
1272
1273 var basic_keys = {
1274     title: "Basic Keys",
1275     key: [
1276         { name: "?",         desc: "show/hide aircraft help dialog" },
1277        #{ name: "Tab",       desc: "show/hide aircraft config dialog" },
1278         { name: "Esc",       desc: "quit FlightGear" },
1279         { name: "Shift-Esc", desc: "reset FlightGear" },
1280         { name: "a/A",       desc: "increase/decrease speed-up" },
1281         { name: "c",         desc: "toggle 3D/2D cockpit" },
1282         { name: "Ctrl-C",    desc: "toggle clickable panel hotspots" },
1283         { name: "p",         desc: "pause/continue sim" },
1284         { name: "Ctrl-R",    desc: "activate instant replay system" },
1285         { name: "t/T",       desc: "increase/decrease warp delta" },
1286         { name: "v/V",       desc: "cycle views (forward/backward)" },
1287         { name: "Ctrl-V",    desc: "select cockpit view" },
1288         { name: "w/W",       desc: "increase/decrease warp" },
1289         { name: "x/X",       desc: "zoom in/out" },
1290         { name: "Ctrl-X",    desc: "reset zoom to default" },
1291         { name: "z/Z",       desc: "increase/decrease visibility" },
1292         { name: "Ctrl-Z",    desc: "reset visibility to default" },
1293         { name: "'",         desc: "display ATC setting dialog" },
1294         { name: "+",         desc: "let ATC/instructor repeat last message" },
1295         { name: "-",         desc: "open chat dialog" },
1296         { name: "_",         desc: "compose chat message" },
1297         { name: "F3",        desc: "capture screen" },
1298         { name: "F10",       desc: "toggle menubar" },
1299        #{ name: "Shift-F1",  desc: "load flight" },
1300        #{ name: "Shift-F2",  desc: "save flight" },
1301         { name: "Shift-F10", desc: "cycle through GUI styles" },
1302     ],
1303 };
1304
1305 var common_aircraft_keys = {
1306     title: "Common Aircraft Keys",
1307     key: [
1308         { name: "Enter",     desc: "move rudder right" },
1309         { name: "0/Insert",  desc: "move rudder left" },
1310         { name: "1/End",     desc: "elevator trim up" },
1311         { name: "2/Down",    desc: "elevator up or increase AP altitude" },
1312         { name: "3/PgDn",    desc: "decr. throttle or AP autothrottle" },
1313         { name: "4/Left",    desc: "move aileron left or adj. AP hdg." },
1314         { name: "5/KP5",     desc: "center aileron, elev., and rudder" },
1315         { name: "6/Right",   desc: "move aileron right or adj. AP hdg." },
1316         { name: "7/Home",    desc: "elevator trim down" },
1317         { name: "8/Up",      desc: "elevator down or decrease AP altitude" },
1318         { name: "9/PgUp",    desc: "incr. throttle or AP autothrottle" },
1319         { name: "Space",     desc: "PTT - Push To Talk (via VoIP)" },
1320         { name: "!/@/#/$",   desc: "select engine 1/2/3/4" },
1321         { name: "b",         desc: "apply all brakes" },
1322         { name: "B",         desc: "toggle parking brake" },
1323        #{ name: "Ctrl-B",    desc: "toggle speed brake" },
1324         { name: "g/G",       desc: "gear up/down" },
1325         { name: "h",         desc: "cycle HUD (head up display)" },
1326         { name: "H",         desc: "cycle HUD brightness" },
1327        #{ name: "i/Shift-i", desc: "normal/alternative HUD" },
1328        #{ name: "j",         desc: "decrease spoilers" },
1329        #{ name: "k",         desc: "increase spoilers" },
1330         { name: "l",         desc: "toggle tail-wheel lock" },
1331         { name: "m/M",       desc: "mixture richer/leaner" },
1332         { name: "n/N",       desc: "propeller finer/coarser" },
1333         { name: "P",         desc: "toggle 2D panel" },
1334         { name: "S",         desc: "swap panels" },
1335         { name: "s",         desc: "fire starter on selected eng." },
1336         { name: ", .",       desc: "left/right brake (comma, period)" },
1337         { name: "~",         desc: "select all engines (tilde)" },
1338         { name: "[ ]",       desc: "flaps up/down" },
1339         { name: "{ }",       desc: "decr/incr magneto on sel. eng." },
1340         { name: "Ctrl-A",    desc: "AP: toggle altitude lock" },
1341         { name: "Ctrl-G",    desc: "AP: toggle glide slope lock" },
1342         { name: "Ctrl-H",    desc: "AP: toggle heading lock" },
1343         { name: "Ctrl-N",    desc: "AP: toggle NAV1 lock" },
1344         { name: "Ctrl-P",    desc: "AP: toggle pitch hold" },
1345         { name: "Ctrl-S",    desc: "AP: toggle auto-throttle" },
1346         { name: "Ctrl-T",    desc: "AP: toggle terrain lock" },
1347         { name: "Ctrl-W",    desc: "AP: toggle wing leveler" },
1348         { name: "F6",        desc: "AP: toggle heading mode" },
1349         { name: "F11",       desc: "open autopilot dialog" },
1350         { name: "F12",       desc: "open radio settings dialog" },
1351         { name: "Shift-F5",  desc: "scroll 2D panel down" },
1352         { name: "Shift-F6",  desc: "scroll 2D panel up" },
1353         { name: "Shift-F7",  desc: "scroll 2D panel left" },
1354         { name: "Shift-F8",  desc: "scroll 2D panel right" },
1355     ],
1356 };
1357
1358 _setlistener("/sim/signals/screenshot", func {
1359      var path = getprop("/sim/paths/screenshot-last");
1360      var button = { button: { legend: "Ok", default: 1, binding: { command: "dialog-close" }}};
1361      var success= getprop("/sim/signals/screenshot");
1362      if (success) {
1363          popupTip("Screenshot written to '" ~ path ~ "'", 3);
1364      } else {
1365          popupTip("Error writing screenshot '" ~ path ~ "'", 600, button);
1366      }
1367 });
1368
1369 var terrasync_stalled = 0;
1370 _setlistener("/sim/terrasync/stalled", func {
1371      var stalled = getprop("/sim/terrasync/stalled");
1372      if (stalled and !terrasync_stalled)
1373      {
1374          var button = { button: { legend: "Ok", default: 1, binding: { command: "dialog-close" }}};
1375          popupTip("Scenery download stalled. Too many errors reported. See log output.", 600, button);
1376      }
1377      terrasync_stalled = stalled;
1378 });
1379
1380 var do_welcome = 1;
1381 _setlistener("/sim/signals/fdm-initialized", func {
1382     var haveTutorials = size(props.globals.getNode("/sim/tutorials", 1).getChildren("tutorial"));
1383     gui.menuEnable("tutorial-start", haveTutorials);
1384     if (do_welcome and haveTutorials)
1385         settimer(func { setprop("/sim/messages/copilot", "Welcome aboard! Need help? Use 'Help -> Tutorials'.");}, 5.0);
1386     do_welcome = 0;
1387 });
1388
1389
1390 ##
1391 # overwrite custom shader settings when quality-level is set on startup
1392 var qualityLevel = getprop("/sim/rendering/shaders/quality-level");
1393 var rembrandtOn = getprop("/sim/rendering/rembrandt/enabled");
1394 if (qualityLevel == -1) {
1395     setprop("/sim/rendering/shaders/custom-settings",1);
1396 }
1397 elsif (qualityLevel != nil) {
1398     setprop("/sim/rendering/shaders/custom-settings",0);
1399     setprop("/sim/rendering/shaders/quality-level-internal",qualityLevel);
1400     if (qualityLevel == 0) {
1401         setprop("/sim/rendering/shaders/skydome",0);
1402     }
1403 }
1404 # overwrite custom shader settings when quality-level is set through the slider
1405 # in the Rendering Options dialog
1406 var update_shader_settings = func() {
1407     if (!getprop("/sim/rendering/shaders/custom-settings")){
1408         var qualityLvl = getprop("/sim/rendering/shaders/quality-level-internal");
1409                 setprop("/sim/rendering/shaders/quality-level", qualityLvl);
1410         setprop("/sim/rendering/shaders/landmass",qualityLvl);
1411         setprop("/sim/rendering/shaders/urban",qualityLvl);
1412         setprop("/sim/rendering/shaders/water",qualityLvl);
1413         if (qualityLvl >= 1.0){
1414             qualityLvl = 1.0;
1415         }
1416         setprop("/sim/rendering/shaders/model",qualityLvl);
1417         setprop("/sim/rendering/shaders/contrails",qualityLvl);
1418         setprop("/sim/rendering/shaders/crop",qualityLvl);
1419         setprop("/sim/rendering/shaders/generic",qualityLvl);
1420         setprop("/sim/rendering/shaders/transition",qualityLvl);
1421     } else {
1422                 setprop("/sim/rendering/shaders/quality-level",-1);
1423         }
1424
1425     if (rembrandtOn) {
1426                 setprop("/sim/rendering/shaders/skydome",0);
1427         }
1428 };
1429 _setlistener("/sim/rendering/shaders/custom-settings", func { update_shader_settings() } );
1430 _setlistener("/sim/rendering/shaders/quality-level-internal",   func { update_shader_settings() } );
1431 update_shader_settings();