FlightGear Qt launcher: Difference between revisions

From FlightGear wiki
Jump to navigation Jump to search
(Added out of date notice, update infobox)
(Add an opening paragraph)
Line 11: Line 11:
|developers  = James Turner (since 03/2015)
|developers  = James Turner (since 03/2015)
}}
}}
The '''Qt Launcher''' is a FlightGear frontend designed as a replacement for [[FGRun]]. Initially designed as a stop-gap solution in FlightGear 3.4 for the problem of support for the [[FlightGear Mac OS X Launcher|old FlightGear Mac launcher]] ending with OS X Yosemite, it has become FlightGear's main launcher for all platforms.


{{Package Management}}
{{Package Management}}

Revision as of 13:12, 15 April 2016

This article or section contains out-of-date information

Please help improve this article by updating it. There may be additional information on the talk page.


FlightGear Qt launcher
The aircraft page of the Qt launcher for FlightGear 3.5 as rendered on Windows 7
The aircraft page of the Qt launcher for FlightGear 3.5 as rendered on Windows 7
Started in 12/2014
Description Integrated frontend for FlightGear designed to replace FGRun
Maintainer(s) James Turner
Contributor(s) James Turner (since 03/2015)
Status Under active development as of 03/2016.

The Qt Launcher is a FlightGear frontend designed as a replacement for FGRun. Initially designed as a stop-gap solution in FlightGear 3.4 for the problem of support for the old FlightGear Mac launcher ending with OS X Yosemite, it has become FlightGear's main launcher for all platforms.

Announcement

As of March 2015, there is heavy activity towards a new UI. There will be the HTML5/browser-based version (called Phi), TorstenD is currently working on, which will only be available after FlightGear has finished booting and initializing because it is a conventional FlightGear subsystem, as well as an internal implementation based on well supported libraries using Qt5 (which James Turner is working on), which will only be available during startup, and won't be running/available later on in its current form (i.e. at run-time), the latter having a strong focus on startup-relevant settings, while the former will only be able to deal with run-time settings.

The parallel development of HTML and Qt based UI happens by intention and is not the result of missing coordination[1]. Most likely, both will use a common service layer to provide necessary data[2].

James Turner is currently prototyping (at the suggestion/encouragement of Curt, Torsten D & others) a GUI integration for FlightGear based on Qt 5. The main motivation originally being that the Mac OSX launcher would no longer work on Yosemite, so an alternative had to be provided.

This is overlapping with some areas other folks are working on (particularly, making the Nasal/Canvas-based Aircraft Center available during startup by Initializing Nasal early), so we felt it best to make an announcement to avoid anyone expending their time on areas that might be affected[3].

All of this would be a QtQuick 2 GUI, not a Qt widgets GUI. If you don’t know what that terminology means, don’t worry about it, the quick answer is it works the same ways as Canvas does at present (rendering to OpenGL).

Cquote1.png the intention is we’re adding integrated convenience features but the command line / shell environment won’t change and the default mode of ‘fgfs’ even in a Qt-enabled build is unchanged. You need set an env var or pass an argument to get the launcher, even if the feature was selected at compile time. We have the advantage that the Windows and Mac pre-built builds, it’s easy to ensure Qt is available, and those users are less likely to want complex command-line control than Linux users.
— James Turner (Oct 11th, 2015). [Flightgear-devel] GUI questions (again).
(powered by Instant-Cquotes)
Cquote2.png

Status

Cquote1.png At some point (possibly quite soon) I’ll enable a version of the Qt launcher to be triggered from the in-sim menu (but as a separate dialog), at least an an experimental feature.
— James Turner (Oct 7th, 2015). Re: [Flightgear-devel] Aircraft catalog - feedback.
(powered by Instant-Cquotes)
Cquote2.png


Cquote1.png I’m currently extending the launcher to do in-air starts
Cquote2.png
Cquote1.png there’s some new features
  • installing / updating aircraft works pretty well, multiple downloads are queued.
  • start location can be any navaid or waypoint, or a lat/lon
  • start offsets (bearing + distance in Nm) are supported
  • navaids are tuned when starting on a runway / using a VOR - command-line box parser supports comments
    — James Turner (Nov 23rd, 2015). [Flightgear-devel] Launcher changes for 3.8.
    (powered by Instant-Cquotes)
Cquote2.png
Cquote1.png Please test and report any other bugs or possible improvements, so this is robust and idiot-proof for 3.8.
— James Turner (Nov 23rd, 2015). [Flightgear-devel] Launcher changes for 3.8.
(powered by Instant-Cquotes)
Cquote2.png

Initial Prototype

Note
Cquote1.png The replacement launcher is very young, so I apologise for any functionality gaps. In general it emphasises setting only the things that cannot be changed at runtime, and some common general settings (real weather, time of day, location). That’s why anti-aliasing and Rembrant are exposed but not multi-player settings, since the in-sim UI works perfectly for those features. The same is true for scenarios and AI traffic.
— James Turner (2015-02-19). Re: [Flightgear-devel] Release 3.4.0 is coming.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png Having many fewer options than FGRun is deliberate and intentional - the idea is to give control over:
  • very commonly used options by most users
  • options that can’t be changed once the simulator is running
This is why for example there’s no control over view settings or multiplayer. (But real-weather and time-of-day are included even though they can be changed in-sim, because I judged them to be common)
— James Turner (Jan 9th, 2016). Re: [Flightgear-devel] Issues with Qt5 launcher.
(powered by Instant-Cquotes)
Cquote2.png

This will be an in-app launcher for Mac initially, based on Qt5. Primarily, because the old Mac launcher doesn’t work on Yosemite, so we are adding a tiny Qt-based launcher inside the main process (no need to fork / exec) which runs before the OSG window is created and before the FlightGear main loop is running, this will be merged for 3.4, hopefully with no impact on other platforms.

The Qt5 stuff is currently only enabled for the Mac/OSX platforms because the corresponding launcher there had to be discontinued (well its dependencies got phased out by Apple) - and shouldn't be used anywhere else (yet)[4].

The qt launcher is not intended for use on non-OSX platforms in 3.4. It's being generalised to work on all platforms on 'next' for 3.6, but it should be ignored by anyone except me in 3.4. (Eg, there is language on the buttons which is OS-X specific, references to 'the Finder')[5]

Some code James has written in the 2014 will be obsolete, e.g. the native message box and menubar code.

User Interface

Cquote1.png I am fairly firm that I /don’t/ want to add many more options, at least before doing a much more serious UI redesign. To explain. the current UI aims to give you control over things you can’t change inside the sim, and also expose very commonly used settings. Keeping the UI clean and uncluttered is a much higher priority than exposing every command line option and feature of the internal GUIs. The longer term solution here is to switch from the current horiontal tabs to a different layout which can support more pages (probably a vertical tab-set with icons), and to put complex options into pages which are hidden by default, and which users can progressively enable. Multiplayer and failures would be possible examples of this.
— James Turner (Nov 26th, 2015). Re: [Flightgear-devel] Launcher changes for 3.8.
(powered by Instant-Cquotes)
Cquote2.png

Preferences

Cquote1.png The preferences file for the launcher is stored in the default location for Qt - which means ~/Library/Preferences on Mac, and the registry on Windows, and whatever XDG/FreeDesktop defines on Linux. You can reset all the FlightGear settings by holding down ‘alt’ on starting the launcher - this also resets any FlightGear saved settings (autosave). Unfortunately pressing alt at the right time is tricky, I’d welcome other suggestions for this.
Cquote2.png

Repercussions

Aircraft Center

Cquote1.png James's new aircraft center looks at his own path on his own web site for aircraft .ip packages (not the previously usual ftp tree.) He created his own scripts to generate the .zip files and named the packages slightly differently from how it was done previously.
Cquote2.png

Qt5 remaining optional

Cquote1.png My personal take is that most normal users /will/ use the Qt-UI build because it will offer the easiest and most integrated GUI experience
— James Turner (Oct 13th, 2015). Re: [Flightgear-devel] GUI questions (again).
(powered by Instant-Cquotes)
Cquote2.png

Limitations

Note that even in the optimistic case, there will be some limitations – e.g., multi-window setup will not work in Qt builds without further work[3].

Dependencies

Cquote1.png There's been a strong devision of opinion among a couple of core developers with respect to the question whether a QT dependency is desirable or not. In one of the hangouts, a couple of months ago, we had the chance to discuss the pros and cons, when the most outspoken developers regarding this issue were both present. We concluded that a QT dependency was undesirable, unless it had a specific benefit. With this in mind, I proposed to consider the option of allowing a QT dependency in only one module (call it FGGui). For all practical purposes, this would be a platform independent replacement of fgrun, but because of the proposed modularity, it will appear to be seamlessly integrated with FlightGear. Both developers representing the opposite ends of the debate could live with this compromise.
— Durk Talsma (2015-06-11). Re: [Flightgear-devel] Policy Document and V4.X Roadmap.
(powered by Instant-Cquotes)
Cquote2.png

For the time being, Qt is only needed for the launcher feature, which is automatically disabled if it is not found[6]. If CMake does not find QT5 then it skips the QT launcher compilation[7]. Thus, Qt5 is an optional build dependency and people can continue to use other other front-ends (fgrun, fgx etc).

On systems without Qt5 support, you will see this:

-- Qt launcher enabled, checking for Qt 5.1 / qmake
CMake Warning at CMakeLists.txt:303 (find_package):
  By not providing "FindQt5.cmake" in CMAKE_MODULE_PATH this project has
  asked CMake to find a package configuration file provided by "Qt5", but
  CMake did not find one.

  Could not find a package configuration file provided by "Qt5" (requested
  version 5.1) with any of the following names:

    Qt5Config.cmake
    qt5-config.cmake

  Add the installation prefix of "Qt5" to CMAKE_PREFIX_PATH or set "Qt5_DIR"
  to a directory containing one of the above files.  If "Qt5" provides a
  separate development package or SDK, be sure it has been installed.

We need to have the discussion if it should become the default launcher for Windows (Linux and other Unixes are less relevant, it’s up to the distribution packagers).

If, how and when the internal gui can leverage Qt is under investigation and in such an early state that those responsible preferred to not announce anything yet. If this ever happens, this will be discussed on the mailing list[8]

Segfaults & Race Conditions

Note  Also see ticket #1819
Cquote1.png Should installing an aircraft to the proper aircraft folder be allowed to crash the launcher if that plane has an error the launcher can detect or should maybe the launcher load and report an error somewhere visible in the launchers gui?
— Ray St. Marie (Sep 3rd, 2015). Re: [Flightgear-devel] fgaddon c310 typos??.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png The problem with GUI coding is that it is very, very hard - it is much more problematic than normal coding and causes far more headaches (from all the banging of your head against the wall trying to work out why it is racing and segfaulting on one system and not another).
— Edward d'Auvergne (Sep 3rd, 2015). Re: [Flightgear-devel] fgaddon c310 typos??.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png Note that as the QtLauncher transitions into a full GUI to replace the PUI GUI, many of these issues will disappear, and new ones will appear. In any case, debugging a modern GUI is much harder than debugging the non-GUI parts. A basic knowledge of threading, locks, and racing is quite useful for understanding and catching these bugs.
— Edward d'Auvergne (Sep 4th, 2015). Re: [Flightgear-devel] Debug build / crash on exit.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png One concern I have though, from the discussions over the last year, is that the PUI->Qt migration plan is not a direct one-to-one migration. I.e. to have a main Qt window providing the main FlightGear window by containing a top menu bar followed by a QtWindow GL widget underneath, in which the FG main execution loop is run as a thread from within the Qt main loop. My impression was that the GUI will be a secondary window or dialog that you have to switch to. But one problem I see with this design is that all modern GUI toolkits (Qt, GTK, metro, Cacoa, Carbon, etc.) suffer from racing and segfaulting issues if the GUI main thread or main loop/event handler is not thread number 1.
— Edward d'Auvergne (Oct 13th, 2015). Re: [Flightgear-devel] GUI questions (again).
(powered by Instant-Cquotes)
Cquote2.png

Canvas

Note  Building a QT based GUI is not in any way meant to obstruct the further development of a Canvas based GUI. We did voice some concerns as to whether the need to re-implement a complete widget is worth the cost is terms of development effort. The beauty of open source is that there's more than one way to do things, however. Especially in a completely modular environment (via HLA) [1].
Cquote1.png Canvas works fine in this scenario, we can embed the texture or image a Canvas produces into a QtQuick dialog just fine. (It would be possible to reimplement Canvas using Qt but I don’t see any benefit there - the non-Qt builds still need Canvas support for flight-displays and the like)
— James Turner (Oct 11th, 2015). [Flightgear-devel] GUI questions (again).
(powered by Instant-Cquotes)
Cquote2.png

James isn't expecting many issues integrating Canvas layers with a Qt GUI, so there is no wasted development effort there (There is the possibility to make a Canvas backend based upon QPainter, which might be a great way to use spare CPU cycles to unload the GPU, however, as Canvas rendering becomes more intensive)[1]. However, at least for the time being, the Qt5 GUI is not even available at run-time, but will be shut down after handing over control to the main FlightGear initialization routines.

Originally, one of the main motivations for adopting Canvas and using it for UI purposes was to help getting rid of PUI (our legacy GUI engine), while coming up with a GUI that would be compatible with other important use-cases (think modern MFDs showing GUI dialogs and vice versa).

The latter is an increasingly important use-case in real life avionics (on jets/airliners) - as can be seen by ARINC 661. Such use-cases aren't easily supported by a distributed approach involving for example a browser, HTML5 and ECMAScript/JavaScript

In addition, the idea is to keep modernizing and unifying the 2D rendering back-end in FlightGear by getting rid of legacy GL code to hopefully use modern OSG code in more and more places: [2]. At least for now, it isn't even clear if/how and when Canvas-based MFDs may support HTML5/Qt5-based UI components or vice versa (e.g. a Qt5 based dialog showing Canvas-based features, such as a MapStructure layer or MFD instances like the NavDisplay). Unlike Canvas-based efforts like the Aircraft Center, the Qt5 effort is also adding a rather significant build-time dependency for those wanting to use the new built-in launcher.

Duplicating existing functionality

Cquote1.png While Qt5 would still be an awesome feature from a Canvas perspective, it is simply not an option as long as it is entirely optional, because at that point, some Canvas-based MFD features would no longer work for FlightGear versions without Qt5 support included.
— Hooray (Jan 10th, 2016). Re: Aircraft reselection .
(powered by Instant-Cquotes)
Cquote2.png

There's also the issue of code duplication and maintenance, too. As can be seen by functionality that is now getting added/re-implemented in Qt5/C++ space, despite already existing elsewhere:

As can be seen, there's currently no code reuse taking place when it comes to the Qt5-based location tab, and the Canvas/MapStructure-based airport/taxiway layers are very much superior in comparison, too (as well as being much better maintainable (living in fgdata)) - so it would make sense to work out a way to reuse existing code instead.

Cquote1.png The main motivation why some people want to have a Nasal/Canvas-based GUI is to ensure that aircraft avionics can make use of the GUI toolkit, but also so that the integrated GUI can deal with existing Canvas based features (think avionics). In layman's terms, all this comes down to being able to render a MFD (PFD/ND) in a dialog box, but also to render GUI widgets to a Canvas, i.e. true recursion - as long as this use-case is supported, it does not matter whether Qt5 is used for this or not, the only thing that matters is that it would be possible to create an integrated GUI for editing/maintaining MFD avionics, but also other Canvas-feature (think having a built-in HUD or 2D panels editor).
— Hooray (Jan 10th, 2016). Re: Aircraft reselection .
(powered by Instant-Cquotes)
Cquote2.png

Once the PropertyBasedElement/CanvasElement wrappers are fully exposed to scripting space, we could easily register MapStructure as a new Canvas element for directly making the corresponding layers available to C++ code, without introducing any direct Nasal dependencies - i.e. the corresponding airports/runway and taxiways diagrams would be transparently created by Nasal-based Canvas elements, with the Qt5/C++ code only ever having to set a handful of properties (airport ICAO id, styling, range etc).

The main obstacle preventing us from doing this right now is that we're not yet Initializing Nasal early, so that the corresponding Nasal/Canvas bindings (via Nasal/CppBind) are not yet available when the Qt5 UI is running.

PLIB/PUI (legacy GUI)

1rightarrow.png See Howto:Processing legacy PUI dialogs using Canvas for the main article about this subject.

Up to now - only a simple replacement for the Mac Launcher has been introduced (and enabled by default only on OSX). This is not related to the internal user interface of FlightGear (which is mainly based on PUI and increasingly Canvas these days), at least for now[3].

However, the goal is to make an optional Qt dependency to replace PLIB PUI[4].

Except of course PUI will have to remain for some awkward use cases in the short term (aircraft dialogs, potentially). When compiled without Qt support, you’ll get a fully functional FG (i.e., Qt will never be a requirement to build FG), but without the GUI functions – which is indeed what some people want anyway (e.g., in some home cockpit setups).

Any in-sim GUI using Qt will exist in parallel to the PLIB/PUI one for at least one major release, although this may mean maintaining two sets of dialogs, unless the XML-translation-tool is good enough that we can use it at run-time for aircraft dialogs[5].

Expect to see a test branch in Git in the next month or so, and hopefully something usable for 3.6. The PLIB code will remain so hopefully it can be a gradual transition[1].

Cquote1.png From what I've seen, I don't see any reason why there cannot be a direct one-to-one migration of the PUI GUI main window to a Qt main window, including dynamically generating the aircraft menu and submenus by parsing the XML unmodified. This can be done incrementally as it is developed, and probably in a way that requiresero changes to the aircraft PUI GUI XML (though changes could be made later, as you can do far, far more with Qt than with PUI). So I personally think that targeting dialogs for the PUI GUI would be the best way to go as this can be directly translated by the GUI developers into Qt dialogs requiring the aircraft developers to do nothing
— Edward d'Auvergne (Oct 13th, 2015). Re: [Flightgear-devel] GUI questions (again).
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png At least for the time being, PUI doesn't seem to become obsolete anytime soon, according to James Turner's continuing preference to hack/extend and maaintain custom PUI widgets:

http://sourceforge.net/p/flightgear/mailman/message/34747786/ This observation is also in line with numerous PUI related commits that he made despite his ongoing Qt5 work: http://wiki.flightgear.org/Canvas_GUI#PUI_Widgets

For a more recent example, look at the waypointlist commits that are using neither Qt5, Phi or Canvas at all: http://sourceforge.net/p/flightgear/flightgear/ci/846fd2
Cquote2.png
Cquote1.png I am strongly against using a very non-standard UI (a text box + slider) to achieve that interaction. I’d much rather we add a spin-box to PUI, which is not especially hard, and give it the ‘click and drag’ mouse interaction which some spinboxes in other apps have, to give similar UI to the sliders without the visual clutter.
— James Turner (Jan 7th, 2016). Re: [Flightgear-devel] Speed-up vs time-warp.
(powered by Instant-Cquotes)
Cquote2.png

FGRun

The upcoming FlightGear 3.6 release is likely to contain an integrated, hard-coded, launcher based on Qt5 to work around the issue of the mac launcher no longer working on Yosemite[1], because James Turner is prototyping a Qt5 cross-platform GUI [2].

Once we have a built-in Qt launcher that's shipped by default on Mac it will probably be used on other OS in the coming release. FGRun will be gone by then, FGRun will be gone with the next release of FlightGear, in favour of a built-in launcher.[3].


Note  In its current form, this section/article is largely based on quotes collected from various related discussions/channels (devel list, forum etc) using the Instant-Cquotes script. Wiki users and other contributors are encouraged to help rewrite/edit contents accordingly to help get rid of unnecessary quoting (i.e. while the wiki is not intended to be a collection of quotes, quotes are sometimes the best/easiest way to bootstrap new articles, while also providing a good way to link back to related discussions in the archives).

While rewriting usually only entails changing first person speech to 3rd person. However, please try to retain references/links to the original discussion whenever possible.


Cquote1.png Gijs was the one who took over fgrun maintenance, and he stated quite clearly that he believes in phasing out fgrun and favoring the new Qt5 based launcher instead
Cquote2.png
Cquote1.png FGRun will be replaced by the built-in launcher in the next weeks, this is a known long term goal that's why FGRun haven't been improved the last 6 months and he won't be improved anymore. By using FGRun you won't be able to use all the new features in the future.
Cquote2.png
Cquote1.png it isn't just a rewrite from scratch... it is built into fgfs... not a separate executable... i suspect that when it is completed, "--launcher" will be removed and it will be the first thing you see when starting fgfs but i could be wrong about that
Cquote2.png
Cquote1.png fgfs has to at least be built with Qt5... on my linux system, i don't recall any Qt5 stuff being installed when i first pulled fgfs 3.4.0 from the PPA where they (sorry, i don't recall his name as i'm still very new and learning everyone) had built 3.4.0 and then 3.4.1 with Qt5... when i started using the download_and_compile script, Qt5 was not installed on my machine so the --launcher option didnt work with my self-compiled 3.5.0... then some updates were made and i got a new copy of the script because of the fgdata split and that did install some Qt5 stuff on my box... i'm guessing that the installers will take care of what needs to be
Cquote2.png
Cquote1.png 3.4 will need, if you have system-side QT5 libraries, namely the qtbase5-dev package on Ubuntu that provides these QT libraries.


i still think FGRUN is ment to stay,,,

edit: at least if you compile stable FG from the brisa's download_and_compile script, you'll need QT, but it might still error compile even if your compiling by hand... but there's an QT conditional commit on Sourceforge's "next" for those without QT, but i'm not sure if it's merged yet into release/3.4


— hamzaalloush (Tue Mar 17). Re: FGRUN I think it's useful add it in a standard way.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png grun is a separate tool, so can obviously be used just as well - and it is very likely that it will be much more complete than the Qt based launcher for at least 2-3 release cycles, which also applies to other polished front-ends, like for example FGx.


However, the mid-term idea is to phase out external launchers and provide built-in means to start up and configure FG using a simple UI.
Also, for the last few years, Gijs has basically been maintaining fgrun - and here's what he had to say about the future of fgrun in fgfs: http://sourceforge.net/p/flightgear/cod ... 1529/#cd07


Cquote2.png
Cquote1.png The other issue here being that the Qt launcher in its current form is implemented in a way that makes it only useful during startup, i.e. the current implementation basically kills the UI once the simulator has initialized. So it's not just a certain disparity features-wise, but the UI also won't be available at run-time, which may take another 1-2 release cycles to address.


Obviously, people can continue to use external launchers like fgrun/fgx still - but there are pretty strong advantages once a built-in launcher is properly integrated - so if/when, the Qt5-based UI will evolve, it is likely that external launchers will generally become obsolete for most purposes/end-users - which isn't such a bad thing actually, given the crazy number of FG GUI front-ends we have seen over the years.

Keep in mind that an external launcher like fgrun will also eat up resources while FG is running - while an integrated solution could be much more efficient.


Cquote2.png
Cquote1.png i applaud this effort by Gijs, but i still think users should be able to use external tools as well, as you have confirmed now thankfully.


since QT is bieng agreed upon to be the launcher for FG accross platforms, does this mean it will merge into FG as well?? i think Canvas is much better for menu since we are using built-in framework.

not to mention other QT dependance and maintanance issues.


— hamzaalloush (Tue Mar 17). Re: FGRUN I think it's useful add it in a standard way.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png the whole step is long overdue - and for FG it is a huge improvement. FlightGear has become a fairly sizable code base, with tons of legacy code, while making very little use of modern frameworks/libraries. Accepting Qt5 as a general dependency would be a huge shift in thinking, and it could help improve/modernize the FG architecture significantly.

However, it's a tedious process, too - i.e. updating all the legacy code accordingly and getting rid of old cruft in the process.
And so far, there's only a single core developer pursuing this. And looking back in time, we've seen similar efforts that ultimately turned out to be too tedious to be accepted by the wider communtiy of contributors, so that such efforts would ultimately turn out to be merely "experiments" - and "iterations" of a process to arrive at a completely different solution.


Cquote2.png


Cquote1.png having started without any kind of launcher and then finding FGRun and now having played with the Qt5 launcher, i do hope that all the capabilities of FGRun are incorporated into the new one... i'm always getting bitten in the arse when i forget to specify something on the command line with the "--launcher" option... "--http=5500" being one of those... there are others... FGRun saves the last used options so the next time they are already set...
Cquote2.png


Python in FlightGear

Cquote1.png depending on how much progress bugman is going to make with his "python-integration-in-FlightGear" experiments (FGPythonSys), we may at some point even be able to ship FFGo as part of FGData (e.g. $FG_ROOT/Python/Apps/FFGo) and run it via FGPythonSys directly
— Hooray (Feb 12th, 2016). Re: Announcing .
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png if this FGPythonSys were integrated into FG, doing things in Python that are directly committed to the core (properly reviewed---well, as the C++ code) as opposed to coming from various uncontrolled external places would certainly be pretty interesting
— rominet (Feb 13th, 2016). Re: Announcing .
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png The built-in launcher that James is writing would seem to me to be a good candidate for doing things in Python (assuming there are good bindings to the C++ data structures): you need high-level access to FG aircraft and airport data, it is not performance critical, the need for threading is certainly rather limited, the code does not come from a random hangar and can be audited just like the C++ code when committed, probably by more people actually. Add to this that PyQt works very well (I have had a very pleasant experience with PyQt 3&4 under Python 2&3, and if I get enough time, I'll maybe port FFGo to PyQt---Tk is useful, clearly, but frustrating; for example Qt's QAbstractItemModel and QAbstractItemView were great to manage non-trivial tablular data; with Tk, table/tree cells are just strings and your program has to manage on its own to link that to the nice high-level Python data structures). (and I have tried other toolkits before Qt and Tk, namely GTK+ 1.2 and wxWidgets [around 2003] Bottom line: for me, Qt is the best)
— rominet (Feb 13th, 2016). Re: Announcing .
(powered by Instant-Cquotes)
Cquote2.png

Testing

The launcher is not run by default, this is because it was created as a Mac only solution.

You can test the launcher by passing the --launcher argument, or setting the $FG_LAUNCHER environment variable. These options exist to allow a Windows shortcut, .desktop file on Linux or the app bundle’s Info.plist to set the value when started from the GUI.

Cquote1.png If you want to use the new one, specify the following parameters in the box at the bottom of the Settings tab:
--console --multiplay=out,10,mpserver01.flightgear.org, --multiplay=in,10,, --callsign=WF01 --visibility=75
(replace the name of the multiplayer server, the callsign and the visibility - in meters - as appropriate).
— elgaton (Feb 18th, 2016). Re: FG 2016,1.1.
(powered by Instant-Cquotes)
Cquote2.png

The GUI launcher included in the nightly builds includes a new dialog to set up (and remember) $FG_ROOT using a file picker dialog. It does some version checking to hopefully make things as robust as possible for the user[1].

And if you run fgfs via the command line with some options, you don’t get troubled by the launcher.

Note  If you need the --console switch, it doesn't appear to work in the launcher command line args area. In Windows however you can add it behind the --launcher switch in the shortcut "Target" path.

Community Feedback

Cquote1.png My issues are:
  • I really would like to be able to see ONLY the planes I have installed on my system and not every single plane available for FG. Maybe a checkbox "show only local planes" could solve this? * I can't use a different FGDATA path, which was a very handy feature of FGRun. Even adding --fg-root=/path/to/fgdata to the "Additional options" field doesn't work. - when trying to add Aircraft and Scenery paths, I am presented with a dialog to find them, but I can't see hidden folders there, and Ctrl+H doesn't affect it
  • I can't seem to be able to move a scenery path up and down to change the priority order, which is fundamental when using custom scenery
  • seems to have much fewer options than FGRun, some of which were handy (for instance, where can I set texture compression now?)
  • I love the airport view but I would expect I could position and rotate my aircraft anywhere by clicking around instead of being able to only select runways (which would be a handy feature to start at a parking position if it's not defined for a given airport)
    — Gilberto Agostinho (Jan 9th, 2016). [Flightgear-devel] Issues with Qt5 launcher.
    (powered by Instant-Cquotes)
Cquote2.png

Cross-Compiling using MingW64

1rightarrow.png See Building FlightGear - Cross Compiling for the main article about this subject.

Cquote1.png they [mxe] still have QT < 5.1, so that's an issue that we will have to resolve at a later date for our new GUI, for now, i will be contempt with cross-compilling FG 3.4 when i'm done just as a proof-of-concept.
Cquote2.png

Development

Note the launcher on next will be in flux shortly as James will add some new features - support for the aircraft package manager especially, and for specifying some directory locations to support "code only" nightly builds (see FlightGear Build Server) which use an existing FGData download[2].

Cquote1.png This [add-on] screen is work-in-progress, I have moved it already in my local version, but didn’t push the changes yet. There’s new UI around the download location too, and the aircraft-dir changes you mention. For aircraft package support in general, I am hoping that setting FG_AIRCRAFT / —fg-aircraft might not be needed, i.e if aircraft-dir is explicitly set, that would be sufficient. This makes having multiple variants of aircraft co-installed much easier for the package system, but will likely need some code fixes as you already identified.
— James Turner (2015-03-31). Re: [Flightgear-devel] Launcher issues on Linux.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png this is an area I’m actively working on, especially how FG to aircraft version handling in the package system works. My current focus is to generate some test hangars on web-hosts to test against, once that works I will call out for other volunteers (Syd Adams already gracefully offered). Expect some churn in this area, in the next few weeks.
— James Turner (2015-03-31). Re: [Flightgear-devel] Non-existent default catalog.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png The problem is the initialisation sequence. The QtLauncher starts before the 'dynamic airports'. Therefore the park positions are not available (unless they have been added to the NavDataCache by previous runs of FG, and the NavDataCache is not rebuilt).
— Edward d'Auvergne (Oct 22nd, 2015). Re: [Flightgear-devel] FGFS Launcher -->selecting Parkpositions ???.
(powered by Instant-Cquotes)
Cquote2.png

Issues

Cquote1.png The default aircraft catalog download path is http://fgfs.goneabitbursar.com/pkg/<version>/default-catalog.xml, which does not exist for 3.4.0 or 3.5.0, giving a "catalog download failure:" error and an empty Aircraft Center [ticket #1737].
— Rebecca N. Palmer (2015-03-31). [Flightgear-devel] Non-existent default catalog.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png The "Add-ons" tab of the launcher has several problems on Linux [see posting for details]
— Rebecca N. Palmer (2015-03-31). [Flightgear-devel] Launcher issues on Linux.
(powered by Instant-Cquotes)
Cquote2.png
Cquote1.png Further investigation found that the launcher *is* trying to add this directory to fg-aircraft (src/GUI/QtLauncher.cxx:772), but that this doesn't work because this option is processed before the launcher is run (intentionally, to allow the launcher to find aircraft in fg-aircraft: src/Main/main.cxx:448).
— Rebecca N. Palmer (2015-04-01). Re: [Flightgear-devel] Launcher issues on Linux.
(powered by Instant-Cquotes)
Cquote2.png
References