It is time to include build and license information here.

CMake 3.13 used on my EP1 machine did not like some of the options in
the files, so for compatibility reasons older ones are used.

This new option of our custom ROOT version is set when it is also set in
the Fp311Online projects.

This updates the submodule reference to point to the current tip of our
own modified ROOT version.

As we have now our own repository for our fork of ROOT, the submodule
path is updated to point to our own GitLab.

The interface of RooDataHist was improved in ROOT 6.24 and the old way of
querying the content of a bin was deprecated.

Therefore, a macro is added to compile code using the new interface on a
ROOT version ≥ 6.24 and do it the old way otherwise.

As we now start using RooFit, we need to link against its library...

As all commands that contain arguments, a dedicated parser method is
added for this one, too.

This new method does the usual input validation. As only three values
are allowed for the only parameter “newstate”, they are explicitly
checked, because “never trust your clients”...

This action gets its own parser to make sure that all necessary values
are present (never trust your clients...).

This adds the necessary “glue” to the library to support the eror
command and extends all switches accordingly.

This is a parsing method like the others, this time for error commands.

In case something goes wrong, it should be possible to send an error
message to the other side...

Under the Filesystem Hierarchy Standard, the includes should go to
<prefix>/include, not <prefix>/share/include...

Normally, one would expect headers in a development package, but if the
header files are not available in the environment where ROOT is run,
Cling will throw error messages.

This even happens when the version of ROOT is printed in int main() of
the server or the client.

Therefore, we also install the header files. Their directory should/must
be put in the environment variable ROOT_INCLUDE_PATH.

When “make install” is called for the main project, some files from ROOT
(binaries, libraries, config files, .rootmap files, etc.) are copied to
the installation prefix given to CMake.

The check if the compilation results from ROOT exist run during cmake
and not make, so in a fresh build directory it will always fail.

This removes these unfulfillable checks and creates the required
directories so the targets can be created.

This new method enables the ExperimentState class to update its
properties when new data has arrived via the updateExperimentState
command.

The logging function aliases cannot be const here because this screws
up the defaulted assignment operators.

This adds the common aliases also to this class in the library.

The ExperimentState class can now put its properties into the update
command. Only the token needs to be added later by the class that
requested the command object.

This was still missing from the collection of the state variables.

The software uses Pascal internally as this is the SI unit, but the old
guide to the real experiment uses Torr, so we add a conversion function
to display both in the GUI.

Hectopascal is identical to millibar, but Pascal is the SI unit, so we
go with it...

The same script as for server and client, but without artifacts because
uploading the static library doesn't yield much use.

This does not matter right now due to static linking, but in case the
common library is used as a shared library in the future, these types
have to be in the export table.

If a custom C++ version is selected, the integrated ROOT build should
also use this version to prevent any inconsistencies within the
application.

The pointer variables in the Qt event handlers can be const and should
therefore also be declared as such.

As ROOT provides sophisticated menus that a novice might screw up, this
adds the option to ignore any input from the user by not passing it on
to ROOT.

As ROOT provides sophisticated menus that a novice might screw up, this
adds the option to ignore any input from the user by not passing it on
to ROOT.

This adds the necessary ties between Qt and ROOT so that the user can
modify the content of the TCanvas as in pure ROOT.

If Qt redraws the GUI, this is forwarded to ROOT's canvas.

This instantiates TCanvas and draws the empty canvas on the widget's
surface area.

This class shall encapsulate a TCanvas instance from ROOT.

The code is inspired by this ROOT forum thread
https://root-forum.cern.ch/t/gvirtualx-addwindow-problem/25215/5
and this example posted there:
https://root-forum.cern.ch/uploads/default/original/2X/4/4f1f5269962b0622a04fa6093c805f5573669df4.gz

This action will allow the clients to select whether the target hole
should be open, closed, or covered with a gold foil.

This verifies the content of the JSON object and constructs a Command
instance with the parameters given there.

The first collection of methods was apparently incomplete, so it is
hereby extended.

This turns a command object instance into a JSON string that can be send
through the websocket.

This struct represents one command sent via th websocket connection in
either direction.

Writing the code parsing an incoming command has been partly written
already.

This enum contains all the commands currently foreseen for the protocol,
although the list may of course be extended later on.