Change to standard markdown for syntax highlighting

tutorials/eve/track.C

@@ -4,10 +4,10 @@
 /// field configurations.
 /// Needs to be run in compiled mode.
 /// root
-/// ~~~ {.cpp}
+/// ```cpp
 ///   .L track.C+
 ///   track(3, kTRUE)
-/// ~~~
+/// ```
 /// void track(Int_t mode = 5, Bool_t isRungeKutta = kTRUE)
 /// Modes are
 ///  0. B = 0, no difference btween signed and charge particles;

tutorials/fit/ErrorIntegral.C

@@ -8,9 +8,9 @@
 ///
 /// run the macro doing:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///  .x ErrorIntegral.C
-/// ~~~
+/// ```
 ///
 /// \macro_image
 /// \macro_output

tutorials/fit/FittingDemo.C

@@ -4,10 +4,10 @@
 /// Example for fitting signal/background.
 /// This example can be executed with:
 ///
-/// ~~~{.cpp}
+/// ```cpp
 /// root > .x FittingDemo.C  (using the CINT interpreter)
 /// root > .x FittingDemo.C+ (using the native complier via ACLIC)
-/// ~~~
+/// ```
 ///
 /// \macro_image
 /// \macro_output

tutorials/fit/Ifit.C

@@ -8,14 +8,14 @@
 ///   More details on the various functions or parameters for these functions
 ///   can be obtained in an interactive ROOT session with:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    Root > TMinuit *minuit = new TMinuit(10);
-/// ~~~
+/// ```
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    Root > minuit->mnhelp("*")  to see the list of possible keywords
 ///    Root > minuit->mnhelp("SET") explains most parameters
-/// ~~~
+/// ```
 ///
 /// \macro_output
 /// \macro_code

tutorials/fit/fit2.C

@@ -10,10 +10,10 @@
 ///
 /// This example can be executed via the interpreter or ACLIC
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///   root > .x fit2.C
 ///   root > .x fit2.C++
-/// ~~~
+/// ```
 ///
 /// \macro_image
 /// \macro_output

tutorials/fit/fit2a.C

@@ -11,10 +11,10 @@
 ///
 /// This example can be executed via the interpreter or/and the compiler
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///   root > .x fit2a.C
 ///   root > .x fit2a.C++
-/// ~~~
+/// ```
 ///
 /// \macro_image
 /// \macro_output

tutorials/fit/fitCircle.C

@@ -5,11 +5,11 @@
 /// Fit a circle through the points and draw
 /// To run the script, do, eg
 ///
-/// ~~~{.cpp}
+/// ```cpp
 ///   root > .x fitCircle.C   (10000 points by default)
 ///   root > .x fitCircle.C(100);  (with only 100 points
 ///   root > .x fitCircle.C(100000);  with ACLIC
-/// ~~~
+/// ```
 ///
 /// \macro_image
 /// \macro_output

tutorials/fit/line3Dfit.C

@@ -5,9 +5,9 @@
 ///
 /// run this macro by doing:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 /// root>.x line3Dfit.C+
-/// ~~~
+/// ```
 ///
 /// \macro_image
 /// \macro_output

tutorials/foam/foam_kanwa.C

@@ -3,9 +3,9 @@
 /// \notebook -js
 /// This program can be execute from the command line as folows:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///      root -l foam_kanwa.C
-/// ~~~
+/// ```
 ///
 /// \macro_code
 ///
@@ -33,7 +33,7 @@ Double_t Camel2(Int_t nDim, Double_t *Xarg){
    Dist +=exp(-(sqr(x-1./3) +sqr(y-1./3))/GamSq)/GamSq/TMath::Pi();
    Dist +=exp(-(sqr(x-2./3) +sqr(y-2./3))/GamSq)/GamSq/TMath::Pi();
    return 0.5*Dist;
-}// Camel2
+}
 //_____________________________________________________________________________
 
 Int_t foam_kanwa(){
@@ -79,5 +79,4 @@ Int_t foam_kanwa(){
    cout<<"--- kanwa ended ---"<<endl;
 
    return 0;
-}//kanwa
-
+}

tutorials/foam/index.md

@@ -27,15 +27,15 @@ is a simple example how to run FOAM in interactive
 mode. To run this macro issue the  following simple command from the
 Linux shell:
 
-~~~ {.cpp}
+```cpp
   root foam_kanwa.C
-~~~
+```
 
 or from CINT:
 
-~~~ {.cpp}
+```cpp
   root [0] .x foam_kanwa.C
-~~~
+```
 
 Simulation will start and graphical canvas with plot
 of the distribution function appear. In this example
@@ -52,10 +52,10 @@ always remember to define Density  method which provides the
 density distribution.
 Enter CINT interpreter and type:
 
-~~~ {.cpp}
+```cpp
   root [0] gSystem->Load("libFoam.so")
   root [1] .x foam_demo.C+
-~~~
+```
 
 to load FOAM library, compile and execute macro foam_demo.C.
 A shared object foam_demo_C.so is created in the current
@@ -66,9 +66,9 @@ including distribution function will be written to disk.
 demonstrates persistency of FOAM classes.
 To run this macro type:
 
-~~~ {.cpp}
+```cpp
   root [0] .x foam_demopers.C
-~~~
+```
 
 Program reads the FOAM object from disk, checks its
 consistency and prints geometry of cells. Next starts the

tutorials/geom/RadioNuclides.C

@@ -9,36 +9,36 @@
 ///
 /// The radionuclides table is loaded on demand by any call:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    TGeoElementRN *TGeoElementTable::GetElementRN(Int_t atomic_number,
 ///                                                  Int_t atomic_charge,
 ///                                                  Int_t isomeric_number)
-/// ~~~
+/// ```
 ///
 /// The isomeric number is optional and the default value is 0.
 ///
 /// To create a radioactive material based on a radionuclide, one should use the
 /// constructor:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    TGeoMaterial(const char *name, TGeoElement *elem, Double_t density)
-/// ~~~
+/// ```
 ///
 /// To create a radioactive mixture, one can use radionuclides as well as stable
 /// elements:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    TGeoMixture(const char *name, Int_t nelements, Double_t density);
 ///    TGeoMixture::AddElement(TGeoElement *elem, Double_t weight_fraction);
-/// ~~~
+/// ```
 ///
 /// Once defined, one can retrieve the time evolution for the radioactive
 /// materials/mixtures by using one of the 2 methods:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    void TGeoMaterial::FillMaterialEvolution(TObjArray *population,
 ///                                             Double_t   precision=0.001)
-/// ~~~
+/// ```
 ///
 /// To use this method, one has to provide an empty TObjArray object that will
 /// be filled with all elements coming from the decay chain of the initial
@@ -47,26 +47,26 @@
 /// The POPULATION list may contain stable elements as well as radionuclides,
 /// depending on the initial elements. To test if an element is a radionuclide:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    Bool_t TGeoElement::IsRadioNuclide() const
-/// ~~~
+/// ```
 ///
 /// All radionuclides in the output population list have attached objects that
 /// represent the time evolution of their fraction of nuclei with respect to the
 /// top radionuclide in the decay chain. These objects (Bateman solutions) can be
 /// retrieved and drawn:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    TGeoBatemanSol *TGeoElementRN::Ratio();
 ///    void TGeoBatemanSol::Draw();
-/// ~~~
+/// ```
 ///
 /// Another method allows to create the evolution of a given radioactive
 /// material/mixture at a given moment in time:
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 ///    TGeoMaterial::DecayMaterial(Double_t time, Double_t precision=0.001)
-/// ~~~
+/// ```
 ///
 /// The method will create the mixture that result from the decay of a initial
 /// material/mixture at TIME, while all resulting elements having a fractional

tutorials/geom/runplugin.C

@@ -6,14 +6,14 @@
 /// volumes acording some arbitrary criteria *WITHOUT* changing the color of the
 /// same volume drawn on branches that do not match the criteria.
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 /// To run:
 /// root[0]   .L iterplugin.cxx+
 /// root[1]   .x runplugin.C
 /// root[2]   select(2,kMagenta);
 /// root[3]   select(3,kBlue)
 /// ...
-/// ~~~
+/// ```
 ///
 /// \macro_code
 ///

tutorials/gl/glparametric.C

@@ -9,13 +9,13 @@
 ///     - Call gStyle->SetCanvasPreferGL(kTRUE)
 ///     - Or create canvas with name, wich contains "gl".
 ///  2. create TGLParametricEquation object.
-/// ~~~ {.cpp}
+/// ```cpp
 ///     TGLParametricEquation *eq = new TGLParametricEquation("name",
 ///     "some FORMULA here - x(u, v)",
 ///     "some FORMULA here - y(u, v)",
 ///     "some FORMULA here - z(u, v)",
 ///     uMin, uMax, vMin, vMax);
-/// ~~~
+/// ```
 ///     where FORMULA is the same string (mathematical expression),
 ///     as in TF2, but you should use 'u' (or 'U') instead of 'x'
 ///     and 'v' (or 'V') instead of 'y'.

tutorials/gl/glparametrics2.C

@@ -9,13 +9,13 @@
 ///     - Call gStyle->SetCanvasPreferGL(kTRUE)
 ///     - Or create canvas with name, wich contains "gl".
 ///  2. create TGLParametricEquation object.
-/// ~~~ {.cpp}
+/// ```cpp
 ///     TGLParametricEquation *eq = new TGLParametricEquation("name",
 ///     "some FORMULA here - x(u, v)",
 ///     "some FORMULA here - y(u, v)",
 ///     "some FORMULA here - z(u, v)",
 ///     uMin, uMax, vMin, vMax);
-/// ~~~
+/// ```
 ///     where FORMULA is the same string (mathematical expression),
 ///     as in TF2, but you should use 'u' (or 'U') instead of 'x'
 ///     and 'v' (or 'V') instead of 'y'.

tutorials/gl/glvox2.C

@@ -6,19 +6,19 @@
 /// codomain is [0, 1] (1. - non-transparent, 0.5 is semitransparent, etc.)
 /// To pass transparency function into painting algorithm, you have to:
 /// 1. Create TF1 object (with symbolic expression like "0.5 * (sin(x) + 1)":
-/// ~~~ {.cpp}
+/// ```cpp
 /// ...
 /// TF1 * tf = new TF1("TransferFunction", "0.5 * (sin(x) + 1)", -10., 10.);
 /// ...
-/// ~~~
+/// ```
 /// IMPORTANT, the name of TF1 object MUST be "TransferFunction".
 /// 2. Add this function into a hist's list of functions:
-/// ~~~ {.cpp}
+/// ```cpp
 /// ...
 /// TList * lof = hist->GetListOfFunctions();
 /// if (lof) lof->Add(tf);
 /// ...
-/// ~~~
+/// ```
 /// It's also possible to use your own function and pass it into TF1, please read
 /// TF1 documentation to learn how.
 ///

tutorials/gl/viewer3DLocal.C

@@ -15,14 +15,14 @@
 /// As we overload TObject::Paint which is called directly from compiled
 /// code, this script must also be compiled to work correctly.
 ///
-/// ~~~ {.cpp}
+/// ```cpp
 /// #if defined(__CINT__) && !defined(__MAKECINT__)
 /// {
 ///    gSystem->CompileMacro("viewer3DLocal.C");
 ///    viewer3DLocal();
 /// }
 /// #else
-/// ~~~
+/// ```
 ///
 /// \macro_code
 ///

tutorials/graphics/graph_edit_playback.C

@@ -3,7 +3,7 @@
 /// This macro plays a recorded ROOT session showing how to perform various
 /// interactive graphical editing operations. The initial graphics setup
 /// was created using the following root commands:
-/// ~~~ {.cpp}
+/// ```cpp
 ///     TRecorder *t = new TRecorder();
 ///     t->Start("graphedit_playback.root");
 ///     gStyle->SetPalette(1);
@@ -24,7 +24,7 @@
 ///     // Here the following "sketch" was done.
 ///
 ///     t->Stop();
-/// ~~~
+/// ```
 /// Note: The previous commands should be copy/pasted into a ROOT session, not
 /// executed as a macro.
 ///

tutorials/graphics/transparency.C

@@ -6,9 +6,9 @@
 /// It is done by specifying the alpha value of a given color.
 /// For instance
 ///
-/// ~~~
+/// ```
 ///    ellipse->SetFillColorAlpha(9, 0.571);
-/// ~~~
+/// ```
 ///
 /// changes the ellipse fill color to the index 9 with an alpha value of 0.571.
 /// 0. would be fully transparent (invisible) and 1. completely opaque (the default).

tutorials/gui/QtFileDialog.C

@@ -4,14 +4,14 @@
 /// See: [https://doc.qt.io/archives/3.3/qfiledialog.html#getOpenFileName](https://doc.qt.io/archives/3.3/qfiledialog.html#getOpenFileName)
 ///
 /// To use, invoke ACLiC from the ROOT prompt:
-/// ~~~
+/// ```
 /// root [] .x QtFileDialog.C++
-/// ~~~
+/// ```
 ///
 /// To use it with no ACLiC, omit the trailing "++"
-/// ~~~
+/// ```
 /// root [] .x QtFileDialog.C
-/// ~~~
+/// ```
 ///
 /// The QtFileDialog returns TString object that contains the selected file name.
 /// returns its pointer.