As this is a library, an initialization macro has to be called to make
sure the Qt resource is loaded and accesible.

The certificate could not be verified against itself due to a problem
with the DN, so it has been regenerated.

For the proper use of the application in a production environment, a
first CA certificate is added to the common library.

This adds the code necessary to process this new command.

This simple command asks the server to send the full content of the
histogram.

Updated CMakeLists.txt to add a boolean option to enable the use of the
development certificate.

If enabled, the resource file of the certificate is added to the sources
of libfp311online and a compiler definition is set.

Managing the SSL certificates requires the class “QSslCertificate” which
is part of Qt5 Network.

This class pulls all CA certificate files from the Qt resource system
after making sure these resources are properly initialized, which is
required as they are part of a static library.

Including this file in the build process or not will be possible by a
CMake option.

This adds the RSA certificate to be used while developing and testing
the application.

DO NOT USE IN PRODUCTION!

Contains a brief explanation and warns against using development
certificates in a production build.

Extend the Command class to use the recently added actions in the
protocol.

Doing this was so far not possible in our protocol...

React properly when the widget is resized...

A closing bracket was in the wrong place...

The missing “$” sign resulted in files being installed in
/app/{CMAKE_INSTALL_SYSCONFDIR}
which causes ROOT to produce a segfault when the first ROOT command
gROOT->GetVersion() is called.

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...