This refactors the CMake build files to no longer manually call
the CMake functions for generating and linking the dicionairies.
One reason is to reduce boilerplate, the other is that it is now
no longer possible to have naming mismatches between the dictionary
generation arguments and linking function arguments which was causing
the race conditions we had in our build system.

This also now follows more strictly the separation between dependencies
like Math, Tree and Core and pure linking flags to external libraries.

This patch instead prints an error with some useful debugging
information that should help identify the cause of this issue.

fCanvasImp was not initialized and could be used in CreatePainter()

The casting of the function to improve lookup didn't took
variadic functions into aspect, causing ABI issues when generating
the code for calling this function. This correctly appends the
annotation for a variadic function to the function type.

This fixes the roottest-python-cling-cling test when compiling
with icc.

Improve closing of CEF messaging queue

When close message send by client, server clear all callbacks and
does not reply on the message. Still X is crashing if close called from
window.onunload handler

Invoked when current canvas version delivered to all clients.

Callback function called when file is created (or command fails)

When synchronous mode specified (defualt), 
method blocked until file is produced. 
With asynchronous mode method returned and file will be produced in
background. 

One can call Canvas::SaveAs() several times, all specified files will be
created one by one asynchronously

It let configure more complex program arguments for starting browser for
the canvas, provide brief docu

By defauly, ROOT will try to crate local window with CEF or Qt5.
If not available, default browser will be started.
If place is specified, it should be program name like:
   canvas->Show("/usr/bin/opera");
   canvas->Show("firefox");

One could show canvas in several different places.

By default, TCanvas::Update() will block until latest canvas 
version delivered to all clients and displayed. Implement with
straight polling loop.

Each call to TCanvas::Modified() increments modify counter. 
This counter used in then next TCanvas::Update() call to identify
current version of canvas. TCanvas::IsModified() will return true 
until drawing is completed and painter confirms that last version of
canvas delivered to all clients and displayed. 

This commit also adds some minor improvements to method descriptions.
It introduces no functional changes.

The tests programs in these folders are not meant to be shown in the reference guide.
This fixes an issues with the TStopwatch doc which had multiple documentation  of the same method.

When chunking and fitting the right amount of elements per chunk you
may end up with empty chunks at the end. This chunks will still consist
of N elements per chunk, but they will not be initialized. Accessing
them was a problem. Solved by reducing the number of chunks (not
allowing empty chunks)

This removes the file dependency between LLVM and the git HEAD file,
which currently causes that we rebuild LLVM/Cling/Dictionaries
once someone does anything meaningful in git.

Currently LLVM LTO and other parts depend on the git HEAD file
because they pull in the current git revision (and should update
when the git revision changes). This is causing some unnecessary
rebuilding everytime someone is touching his git HEAD file.

This commit is disabling this in future LLVM versions by setting
the appropriate flag in LLVM to OFF (doesn't do a lot by now
as we first need to get this revision in the ROOT llvm version
https://reviews.llvm.org/D35377).

because two input parameters are not basic types.

The issue was mentioned here: https://sft.its.cern.ch/jira/browse/ROOT-8927