    // @(#)root/postscript:$Name:  $:$Id: TSVG.cxx,v 1.10 2004/03/17 17:35:32 brun Exp $
    // Author: Olivier Couet

    /*************************************************************************
     * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
     * All rights reserved.                                                  *
     *                                                                       *
     * For the licensing terms see $ROOTSYS/LICENSE.                         *
     * For the list of contributors see $ROOTSYS/README/CREDITS.             *
     *************************************************************************/

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // TSVG                                                                 //
    //                                                                      //
    // Graphics interface to SVG.                                           //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    #ifdef WIN32
    #pragma optimize("",off)
    #endif

    #include <stdlib.h>
    #include <string.h>
    #include <ctype.h>

    #include "Riostream.h"
    #include "TROOT.h"
    #include "TColor.h"
    #include "TVirtualPad.h"
    #include "TPoints.h"
    #include "TSVG.h"
    #include "TStyle.h"
    #include "TMath.h"

    ClassImp(TSVG)

    //______________________________________________________________________________
    //

/* SVG is a language for describing two-dimensional graphics in XML. SVG allows for three types of graphic objects: vector graphic shapes, images and text. Graphical objects can be grouped, styled, transformed and composed into previously rendered objects. The feature set includes nested transformations, clipping paths, alpha masks, filter effects and template objects. SVG drawings can be interactive and dynamic. Animations can be defined and triggered either declaratively or via scripting.

The way to access SVG in ROOT (in my private version only) is the following:

       TSVG mysvg("myfile.svg")
       object->Draw();
       mysvg.Close();

The result is the ASCII file `myfile.svg`, it is best viewed with Internet Explorer and you need the Adobe SVG Viewer. To zoom using the Adobe SVG Viewer, position the mouse over the area you want to zoom and click the right button. To define the zoom area, use Control+drag to mark the boundaries of the zoom area. To pan, use Alt+drag. By clicking with the right mouse button on the SVG graphics you will get a pop-up menu giving other ways to interact with the image.

SVG files can be used directly in compressed mode to minimize the time transfer over the network. Compressed SVG files should be created using `gzip` on a normal ASCII SVG file and should then be renamed using the file extension `.svgz`. */ //

    //______________________________________________________________________________
     TSVG::TSVG() : TVirtualPS()
    {
       // Default SVG constructor

       fStream = 0;
       fType   = 0;
       gVirtualPS = this;
    }

    //______________________________________________________________________________
     TSVG::TSVG(const char *fname, Int_t wtype) : TVirtualPS(fname, wtype)
    {
       // Initialize the SVG interface
       //
       //  fname : SVG file name
       //  wtype : SVG workstation type. Not used in the SVG driver. But as TSVG
       //          inherits from TVirtualPS it should be kept. Anyway it is not
       //          necessary to specify this parameter at creation time because it
       //          has a default value (which is ignore in the SVG case).

       fStream = 0;
       Open(fname, wtype);
    }

    //______________________________________________________________________________
     void TSVG::Open(const char *fname, Int_t wtype)
    {
       // Open a SVG file

       if (fStream) {
          Warning("Open", "SVG file already open");
          return;
       }

       fLenBuffer = 0;
       fType      = abs(wtype);
       SetLineScale(gStyle->GetLineScalePS());
       gStyle->GetPaperSize(fXsize, fYsize);
       Float_t xrange, yrange;
       if (gPad) {
          Double_t ww = gPad->GetWw();
          Double_t wh = gPad->GetWh();
          ww *= gPad->GetWNDC();
          wh *= gPad->GetHNDC();
          Double_t ratio = wh/ww;
          xrange = fXsize;
          yrange = fXsize*ratio;
          if (yrange > fYsize) { yrange = fYsize; xrange = yrange/ratio;}
          fXsize = xrange; fYsize = yrange;
       }

       // Open OS file
       fStream   = new ofstream(fname,ios::out
       if (fStream == 0) {
          printf("ERROR in TSVG::Open: Cannot open file:%sn",fname);
          return;
       }

       gVirtualPS = this;

       for (Int_t i=0;i<fSizBuffer;i++) fBuffer[i] = ' ';

       fBoundingBox = kFALSE;

       fRange       = kFALSE;

       // Set a default range
       Range(fXsize, fYsize);

       NewPage();
    }

    //______________________________________________________________________________
     TSVG::~TSVG()
    {
       // Default SVG destructor

       Close();
    }

    //______________________________________________________________________________
     void TSVG::Close(Option_t *)
    {
       // Close a SVG file
       if (!gVirtualPS) return;
       if (!fStream) return;
       if (gPad) gPad->Update();
       PrintStr("</svg>@");

       // Close file stream
       if (fStream) { fStream->close(); delete fStream; fStream = 0;}

       gVirtualPS = 0;
    }

    //______________________________________________________________________________
     void TSVG::On()
    {
       // Activate an already open SVG file

       // fType is used to know if the SVG file is open. Unlike TPostScript, TSVG
       // has no "workstation type". In fact there is only one SVG type.

       if (!fType) {
          Error("On", "no SVG file open");
          Off();
          return;
       }
       gVirtualPS = this;
    }

    //______________________________________________________________________________
     void TSVG::Off()
    {
       // Deactivate an already open SVG file

       gVirtualPS = 0;
    }

    //______________________________________________________________________________
     void TSVG::DrawBox(Double_t x1, Double_t y1, Double_t x2, Double_t  y2)
    {
       // Draw a Box

       static Double_t x[4], y[4];
       Int_t ix1 = XtoSVG(x1);
       Int_t ix2 = XtoSVG(x2);
       Int_t iy1 = YtoSVG(y1);
       Int_t iy2 = YtoSVG(y2);
       Int_t fillis = fFillStyle/1000;
       Int_t fillsi = fFillStyle%1000;

       if (fillis == 3 || fillis == 2) {
          if (fillsi > 99) {
             x[0] = x1;   y[0] = y1;
             x[1] = x2;   y[1] = y1;
             x[2] = x2;   y[2] = y2;
             x[3] = x1;   y[3] = y2;
             return;
          }
          if (fillsi > 0 && fillsi < 26) {
             x[0] = x1;   y[0] = y1;
             x[1] = x2;   y[1] = y1;
             x[2] = x2;   y[2] = y2;
             x[3] = x1;   y[3] = y2;
             DrawPS(-4, &x[0], &y[0]);
          }
          if (fillsi == -3) {
             PrintFast(9,"<rect x="");
             WriteInteger(ix1, 0);
             PrintFast(5,"" y="");
             WriteInteger(iy2, 0);
             PrintFast(9,"" width="");
             WriteInteger(ix2-ix1, 0);
             PrintFast(10,"" height="");
             WriteInteger(iy1-iy2, 0);
             PrintFast(7,"" fill=");
             SetColor(5);
             PrintFast(2,"/>");
          }
       }
       if (fillis == 1) {
          PrintFast(9,"<rect x="");
          WriteInteger(ix1, 0);
          PrintFast(5,"" y="");
          WriteInteger(iy2, 0);
          PrintFast(9,"" width="");
          WriteInteger(ix2-ix1, 0);
          PrintFast(10,"" height="");
          WriteInteger(iy1-iy2, 0);
          PrintFast(7,"" fill=");
          SetColor(fFillColor);
          PrintFast(2,"/>");
       }
       if (fillis == 0) {
          PrintFast(9,"<rect x="");
          WriteInteger(ix1, 0);
          PrintFast(5,"" y="");
          WriteInteger(iy2, 0);
          PrintFast(9,"" width="");
          WriteInteger(ix2-ix1, 0);
          PrintFast(10,"" height="");
          WriteInteger(iy1-iy2, 0);
          PrintFast(21,"" fill="none" stroke=");
          SetColor(fLineColor);
          PrintFast(2,"/>");
       }
    }

    //______________________________________________________________________________
     void TSVG::DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t  yt,
                                Int_t mode, Int_t border, Int_t dark, Int_t light)
    {
       // Draw a Frame around a box
       //
       // mode = -1  the box looks as it is behind the screen
       // mode =  1  the box looks as it is in front of the screen
       // border is the border size in already pre-computed SVG units dark is the
       // color for the dark part of the frame light is the color for the light
       // part of the frame

       static Int_t xps[7], yps[7];
       Int_t i, ixd0, iyd0, idx, idy, ixdi, iydi, ix, iy;

       //- Draw top&left part of the box

       xps[0] = XtoSVG(xl);          yps[0] = YtoSVG(yl);
       xps[1] = xps[0] + border;     yps[1] = yps[0] - border;
       xps[2] = xps[1];              yps[2] = YtoSVG(yt) + border;
       xps[3] = XtoSVG(xt) - border; yps[3] = yps[2];
       xps[4] = XtoSVG(xt);          yps[4] = YtoSVG(yt);
       xps[5] = xps[0];              yps[5] = yps[4];
       xps[6] = xps[0];              yps[6] = yps[0];

       ixd0 = xps[0];
       iyd0 = yps[0];
       PrintFast(10,"<path d="M");
       WriteInteger(ixd0, 0);
       PrintFast(1,",");
       WriteInteger(iyd0, 0);

       idx = 0;
       idy = 0;
       for (i=1; i<7; i++) {
          ixdi = xps[i];
          iydi = yps[i];
          ix   = ixdi - ixd0;
          iy   = iydi - iyd0;
          ixd0 = ixdi;
          iyd0 = iydi;
          if( ix && iy) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( idy ) { MovePS(0,idy); idy = 0; }
             MovePS(ix,iy);
             continue;
          }
          if ( ix ) {
             if( idy )  { MovePS(0,idy); idy = 0; }
             if( !idx ) { idx = ix; continue;}
             if( ix*idx > 0 ) {
                idx += ix;
             } else {
                MovePS(idx,0);
                idx  = ix;
             }
             continue;
          }
          if( iy ) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( !idy) { idy = iy; continue;}
             if( iy*idy > 0 ) {
                idy += iy;
             } else {
                MovePS(0,idy);
                idy  = iy;
             }
          }
       }
       if( idx ) MovePS(idx,0);
       if( idy ) MovePS(0,idy);
       PrintFast(8,"z" fill=");
       if (mode == -1) {
          SetColor(dark);
       } else {
          SetColor(light);
       }
       PrintFast(2,"/>");

       //- Draw bottom&right part of the box
       xps[0] = XtoSVG(xl);          yps[0] = YtoSVG(yl);
       xps[1] = xps[0] + border;     yps[1] = yps[0] - border;
       xps[2] = XtoSVG(xt) - border; yps[2] = yps[1];
       xps[3] = xps[2];              yps[3] = YtoSVG(yt) + border;
       xps[4] = XtoSVG(xt);          yps[4] = YtoSVG(yt);
       xps[5] = xps[4];              yps[5] = yps[0];
       xps[6] = xps[0];              yps[6] = yps[0];

       ixd0 = xps[0];
       iyd0 = yps[0];
       PrintFast(10,"<path d="M");
       WriteInteger(ixd0, 0);
       PrintFast(1,",");
       WriteInteger(iyd0, 0);

       idx = 0;
       idy = 0;
       for (i=1;i<7;i++) {
          ixdi = xps[i];
          iydi = yps[i];
          ix   = ixdi - ixd0;
          iy   = iydi - iyd0;
          ixd0 = ixdi;
          iyd0 = iydi;
          if( ix && iy) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( idy ) { MovePS(0,idy); idy = 0; }
             MovePS(ix,iy);
             continue;
          }
          if ( ix ) {
             if( idy )  { MovePS(0,idy); idy = 0; }
             if( !idx ) { idx = ix; continue;}
             if( ix*idx > 0 ) {
                idx += ix;
             } else {
                MovePS(idx,0);
                idx  = ix;
             }
             continue;
          }
          if( iy ) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( !idy) { idy = iy; continue;}
             if( iy*idy > 0 ) {
                idy += iy;
             } else {
                MovePS(0,idy);
                idy  = iy;
             }
          }
       }
       if( idx ) MovePS(idx,0);
       if( idy ) MovePS(0,idy);
       PrintFast(8,"z" fill=");
       if (mode == -1) {
          SetColor(light);
       } else {
          SetColor(dark);
       }
       PrintFast(2,"/>");
    }

    //______________________________________________________________________________
     void TSVG::DrawPolyLine(Int_t nn, TPoints *xy)
    {
       // Draw a PolyLine
       //
       //  Draw a polyline through  the points  xy.
       //  If NN=1 moves only to point x,y.
       //  If NN=0 the x,y are  written  in the SVG        file
       //     according to the current transformation.
       //  If NN>0 the line is clipped as a line.
       //  If NN<0 the line is clipped as a fill area.

       Int_t  n, ixd0, iyd0, idx, idy, ixdi, iydi, ix, iy;

       if (nn > 0) {
          n = nn;
    ///     SetLineStyle(fLineStyle);
    ///     SetLineWidth(fLineWidth);
    ///     SetColor(Int_t(fLineColor));
       } else {
          n = -nn;
    ///     SetLineStyle(1);
    ///     SetLineWidth(1);
    ///     SetColor(Int_t(fLineColor));
       }

       ixd0 = XtoSVG(xy[0].GetX());
       iyd0 = YtoSVG(xy[0].GetY());
    ///  WriteInteger(ixd0);
    ///  WriteInteger(iyd0);
       if( n <= 1) {
          if( n == 0) return;
    ///     PrintFast(2," m");
          return;
       }

       PrintFast(2," m");
       idx = 0;
       idy = 0;
       for (Int_t i=1;i<n;i++) {
          ixdi = XtoSVG(xy[i].GetX());
          iydi = YtoSVG(xy[i].GetY());
          ix   = ixdi - ixd0;
          iy   = iydi - iyd0;
          ixd0 = ixdi;
          iyd0 = iydi;
          if( ix && iy) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( idy ) { MovePS(0,idy); idy = 0; }
             MovePS(ix,iy);
             continue;
          }
          if ( ix ) {
             if( idy )  { MovePS(0,idy); idy = 0; }
             if( !idx ) { idx = ix; continue;}
             if( ix*idx > 0 ) {
                idx += ix;
             } else {
                MovePS(idx,0);
                idx  = ix;
             }
             continue;
          }
          if( iy ) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( !idy) { idy = iy; continue;}
             if( iy*idy > 0 ) {
                idy += iy;
             } else {
                MovePS(0,idy);
                idy  = iy;
             }
          }
       }
       if( idx ) MovePS(idx,0);
       if( idy ) MovePS(0,idy);

       if (nn > 0 ) {
    ///     if (xy[0].GetX() == xy[n-1].GetX() && xy[0].GetY() == xy[n-1].GetY()) PrintFast(3," cl");
    ///     PrintFast(2," s");
       } else {
    ///     PrintFast(2," f");
       }
    }

    //______________________________________________________________________________
     void TSVG::DrawPolyLineNDC(Int_t nn, TPoints *xy)
    {
       // Draw a PolyLine in NDC space
       //
       //  Draw a polyline through  the points  xy.
       //  If NN=1 moves only to point x,y.
       //  If NN=0 the x,y are  written  in the SVG        file
       //     according to the current transformation.
       //  If NN>0 the line is clipped as a line.
       //  If NN<0 the line is clipped as a fill area.

       Int_t  n, ixd0, iyd0, idx, idy, ixdi, iydi, ix, iy;

       if (nn > 0) {
          n = nn;
    ///     SetLineStyle(fLineStyle);
    ///     SetLineWidth(fLineWidth);
    ///     SetColor(Int_t(fLineColor));
       } else {
          n = -nn;
    ///     SetLineStyle(1);
    ///     SetLineWidth(1);
    ///     SetColor(Int_t(fLineColor));
       }

       ixd0 = UtoSVG(xy[0].GetX());
       iyd0 = VtoSVG(xy[0].GetY());
    ///  WriteInteger(ixd0);
    ///  WriteInteger(iyd0);
       if( n <= 1) {
          if( n == 0) return;
    ///     PrintFast(2," m");
          return;
       }

    ///  PrintFast(2," m");
       idx = 0;
       idy = 0;
       for (Int_t i=1;i<n;i++) {
          ixdi = UtoSVG(xy[i].GetX());
          iydi = VtoSVG(xy[i].GetY());
          ix   = ixdi - ixd0;
          iy   = iydi - iyd0;
          ixd0 = ixdi;
          iyd0 = iydi;
          if( ix && iy) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( idy ) { MovePS(0,idy); idy = 0; }
             MovePS(ix,iy);
             continue;
          }
          if ( ix ) {
             if( idy )  { MovePS(0,idy); idy = 0; }
             if( !idx ) { idx = ix; continue;}
             if( ix*idx > 0 ) {
                idx += ix;
             } else {
                MovePS(idx,0);
                idx  = ix;
             }
             continue;
          }
          if( iy ) {
             if( idx ) { MovePS(idx,0); idx = 0; }
             if( !idy) { idy = iy; continue;}
             if( iy*idy > 0 ) {
                idy += iy;
             } else {
                MovePS(0,idy);
                idy  = iy;
             }
          }
       }
       if( idx ) MovePS(idx,0);
       if( idy ) MovePS(0,idy);

       if (nn > 0 ) {
          if (xy[0].GetX() == xy[n-1].GetX() && xy[0].GetY() == xy[n-1].GetY()) PrintFast(3," cl");
    ///     PrintFast(2," s");
       } else {
    ///     PrintFast(2," f");
       }
    }

    //______________________________________________________________________________
     void TSVG::DrawPS(Int_t nn, Double_t *xw, Double_t *yw)
    {
       // This function defines a path with xw and yw and draw it according the
       // value of nn:
       //
       //  If nn>0 a line is drawn.
       //  If nn<0 a closed polygon is drawn.

    ///   static Float_t dyhatch[24] = {.0075,.0075,.0075,.0075,.0075,.0075,.0075,.0075,
    ///                                 .01  ,.01  ,.01  ,.01  ,.01  ,.01  ,.01  ,.01  ,
    ///                                 .015 ,.015 ,.015 ,.015 ,.015 ,.015 ,.015 ,.015};
    ///   static Float_t anglehatch[24] = {180, 90,135, 45,150, 30,120, 60,
    ///                                    180, 90,135, 45,150, 30,120, 60,
    ///                                    180, 90,135, 45,150, 30,120, 60};
       Int_t  n, ixd0, iyd0, idx, idy, ixdi, iydi, ix, iy, fais, fasi;
       fais = fasi = 0;

       if (nn > 0) {
          n = nn;
       } else {
          n = -nn;
          fais = fFillStyle/1000;
          fasi = fFillStyle%1000;
          if (fais == 3 || fais == 2) {
             if (fasi > 100 && fasi <125) {
    ///        DrawHatch(dyhatch[fasi-101],anglehatch[fasi-101], n, xw, yw);
                return;
             }
             if (fasi > 0 && fasi < 26) {
    ///        SetFillPatterns(fasi, Int_t(fFillColor));
             }
          }
       }

        if( n <= 1) {
           Error("DrawPS", "Two points are needed");
           return;
        }

        ixd0 = XtoSVG(xw[0]);
        iyd0 = YtoSVG(yw[0]);

        PrintFast(10,"<path d="M");
        WriteInteger(ixd0, 0);
        PrintFast(1,",");
        WriteInteger(iyd0, 0);

        idx = idy = 0;
        for (Int_t i=1;i<n;i++) {
           ixdi = XtoSVG(xw[i]);
           iydi = YtoSVG(yw[i]);
           ix   = ixdi - ixd0;
           iy   = iydi - iyd0;
           ixd0 = ixdi;
           iyd0 = iydi;
           if( ix && iy) {
              if( idx ) { MovePS(idx,0); idx = 0; }
              if( idy ) { MovePS(0,idy); idy = 0; }
              MovePS(ix,iy);
           } else if ( ix ) {
              if( idy )  { MovePS(0,idy); idy = 0;}
              if( !idx ) { idx = ix;}
              else if( TMath::Sign(ix,idx) == ix )       idx += ix;
              else { MovePS(idx,0);  idx  = ix;}
           } else if( iy ) {
              if( idx ) { MovePS(idx,0); idx = 0;}
              if( !idy) { idy = iy;}
              else if( TMath::Sign(iy,idy) == iy)         idy += iy;
              else { MovePS(0,idy);    idy  = iy;}
           }
        }
        if (idx) MovePS(idx,0);
        if (idy) MovePS(0,idy);

        if (nn > 0 ) {
           if (xw[0] == xw[n-1] && yw[0] == yw[n-1]) PrintFast(1,"z");
           PrintFast(21,"" fill="none" stroke=");
           SetColor(fLineColor);
           if(fLineWidth > 1.) {
              PrintFast(15," stroke-width="");
              WriteInteger(Int_t(fLineWidth), 0);
              PrintFast(1,""");
           }
           if (fLineStyle == 2) {
              PrintFast(23," stroke-dasharray="3,3"");
           } else if (fLineStyle == 3) {
              PrintFast(23," stroke-dasharray="1,4"");
           } else if (fLineStyle == 4) {
              PrintFast(27," stroke-dasharray="3,4,1,4"");
           }
           PrintFast(2,"/>");
        } else {
           PrintFast(8,"z" fill=");
           if (fais == 0) {
              PrintFast(14,""none" stroke=");
              SetColor(fFillColor);
    ///      } else if (fais == 3 || fais == 2) {
    ///        if (fasi > 0 && fasi < 26) {
    ///           Put SVG patterns here
           } else {
              SetColor(fFillColor);
           }
           PrintFast(2,"/>");
        }
    }

    //______________________________________________________________________________
     void TSVG::Initialize()
    {
       // Initialize the SVG file. The main task of the function is to ouput the
       // SVG header file which consist in <title>, <desc> and <defs>. The
       // HeaderPS provided by the user program is written in the <defs> part.

       // Title
       PrintStr("<title>@");
       PrintStr(GetName());
       PrintStr("@");
       PrintStr("</title>@");

       // Description
       PrintStr("<desc>@");
       PrintFast(22,"Creator: ROOT Version ");
       PrintStr(gROOT->GetVersion());
       PrintStr("@");
       PrintFast(14,"CreationDate: ");
       TDatime t;
       PrintStr(t.AsString());
       //Check a special header is defined in the current style
       Int_t nh = strlen(gStyle->GetHeaderPS());
       if (nh) {
          PrintFast(nh,gStyle->GetHeaderPS());
       }
       PrintStr("</desc>@");

       // Definitions
       PrintStr("<defs>@");
       PrintStr("</defs>@");

    }

    //______________________________________________________________________________
     void TSVG::MovePS(Int_t ix, Int_t iy)
    {
       // Move to a new position (ix, iy). The move is done in relative coordinates
       // which allows to have short numbers which decrease the size of the file.
       // This function use the full power of the SVG's paths by using the
       // horizontal and vertical move whenever it is possible.

       if (ix != 0 && iy != 0)  {
          PrintFast(1,"l");
          WriteInteger(ix, 0);
          PrintFast(1,",");
          WriteInteger(iy, 0);
       } else if (ix != 0)  {
          PrintFast(1,"h");
          WriteInteger(ix, 0);
       } else if (iy != 0)  {
          PrintFast(1,"v");
          WriteInteger(iy, 0);
       }
    }

    //______________________________________________________________________________
     void TSVG::NewPage()
    {
       // Start the SVG page. This function initialize the pad conversion
       // coefficients and ouput the <svg> directive which is close later in the
       // the function Close.

       // Compute pad conversion coefficients
       if (gPad) {
          Double_t ww   = gPad->GetWw();
          Double_t wh   = gPad->GetWh();
          fYsize        = fXsize*wh/ww;
       } else {
          fYsize = 27;
       }

       // <svg> directive. It defines the viewBox.
       if(!fBoundingBox) {
          PrintStr("@<svg viewBox="0 0");
          WriteInteger(CMtoSVG(fXsize));
          fYsizeSVG = CMtoSVG(fYsize);
          WriteInteger(fYsizeSVG);
          PrintStr("" xmlns="http://www.w3.org/2000/svg">");
          PrintStr("@");
          Initialize();
          fBoundingBox  = kTRUE;
       }
    }

    //______________________________________________________________________________
     void TSVG::Range(Float_t xsize, Float_t ysize)
    {
       // Set the range for the paper in centimetres

       Float_t xps, yps, xncm, yncm, dxwn, dywn, xwkwn, ywkwn, xymax;

       fXsize = xsize;
       fYsize = ysize;

       xps = xsize;
       yps = ysize;

       if( xsize <= xps && ysize < yps) {
          if ( xps > yps ) xymax = xps;
          else             xymax = yps;
          xncm  = xsize/xymax;
          yncm  = ysize/xymax;
          dxwn  = ((xps/xymax)-xncm)/2;
          dywn  = ((yps/xymax)-yncm)/2;
       } else {
          if (xps/yps < 1) xwkwn = xps/yps;
          else             xwkwn = 1;
          if (yps/xps < 1) ywkwn = yps/xps;
          else             ywkwn = 1;

          if (xsize < ysize)  {
             xncm = ywkwn*xsize/ysize;
             yncm = ywkwn;
             dxwn = (xwkwn-xncm)/2;
             dywn = 0;
             if( dxwn < 0) {
                xncm = xwkwn;
                dxwn = 0;
                yncm = xwkwn*ysize/xsize;
                dywn = (ywkwn-yncm)/2;
             }
          } else {
             xncm = xwkwn;
             yncm = xwkwn*ysize/xsize;
             dxwn = 0;
             dywn = (ywkwn-yncm)/2;
             if( dywn < 0) {
                yncm = ywkwn;
                dywn = 0;
                xncm = ywkwn*xsize/ysize;
                dxwn = (xwkwn-xncm)/2;
             }
          }
       }
       fRange = kTRUE;
    }

    //______________________________________________________________________________
     void TSVG::SetFillColor( Color_t cindex )
    {
       // Set color index for fill areas

       fFillColor = cindex;
       if (gStyle->GetFillColor() <= 0) cindex = 0;
    }

    //______________________________________________________________________________
     void TSVG::SetLineColor( Color_t cindex )
    {
       // Set color index for lines

       fLineColor = cindex;
    }

    //______________________________________________________________________________
     void TSVG::SetLineStyle(Style_t linestyle)
    {
       // Change the line style
       //
       // linestyle = 2 dashed
       //           = 3 dotted
       //           = 4 dash-dotted
       //           = else solid (1 in is used most of the time)

       fLineStyle = linestyle;
    }

    //______________________________________________________________________________
     void TSVG::SetLineWidth(Width_t linewidth)
    {
       // Set the lines width.

       fLineWidth = linewidth;
    }

    //______________________________________________________________________________
     void TSVG::SetMarkerColor( Color_t cindex )
    {
       // Set color index for markers.

       fMarkerColor = cindex;
    }

    //______________________________________________________________________________
     void TSVG::SetColor(Int_t color)
    {
       // Set color with its color index

       if (color < 0) color = 0;
       TColor *col = gROOT->GetColor(color);
       if (col) {
          SetColor(col->GetRed(), col->GetGreen(), col->GetBlue());
       } else {
          SetColor(1., 1., 1.);
       }
    }

    //______________________________________________________________________________
     void TSVG::SetColor(Float_t r, Float_t g, Float_t b)
    {
       // Set color with its R G B components
       //
       //  r: % of red in [0,1]
       //  g: % of green in [0,1]
       //  b: % of blue in [0,1]

       if (r <= 0. && g <= 0. && b <= 0. ) {
          PrintFast(7,""black"");
       } else if (r >= 1. && g >= 1. && b >= 1. ) {
          PrintFast(7,""white"");
       } else {
          char str[12];
          sprintf(str,""#%2.2x%2.2x%2.2x"",Int_t(255.*r)
                                            ,Int_t(255.*g)
                                            ,Int_t(255.*b));
          PrintStr(str);
       }
    }

    //______________________________________________________________________________
     void TSVG::SetTextColor( Color_t cindex )
    {
       // Set color index for text

       fTextColor = cindex;
    }

    //______________________________________________________________________________
     void TSVG::Text(Double_t xx, Double_t yy, const char *chars)
    {
       // Draw text
       //
       // xx: x position of the text
       // yy: y position of the text
       // chars: text to be drawn

       static const char *fontFamily[] = {
       "Times", "Times", "Times",
       "Helvetica", "Helvetica", "Helvetica", "Helvetica",
       "Courier", "Courier", "Courier", "Courier",
       "Symbol","Times", "ZapfDingbats"};

       static const char *fontWeight[] = {
       "normal", "bold", "bold",
       "normal", "normal", "bold", "bold",
       "normal", "normal", "bold", "bold",
       "normal","normal", "normal"};

       static const char *fontStyle[] = {
       "italic", "normal", "italic",
       "normal", "oblique", "normal", "oblique",
       "normal", "oblique", "normal", "oblique",
       "normal","normal", "normal"};

       Int_t ix    = XtoSVG(xx);
       Int_t iy    = YtoSVG(yy);
       Int_t txalh = fTextAlign/10;
       if (txalh <1) txalh = 1; if (txalh > 3) txalh = 3;
       Int_t txalv = fTextAlign%10;
       if (txalv <1) txalv = 1; if (txalv > 3) txalv = 3;

       Double_t     wh = (Double_t)gPad->XtoPixel(gPad->GetX2());
       Double_t     hh = (Double_t)gPad->YtoPixel(gPad->GetY1());
       Float_t fontrap = 1.09; //scale down compared to X11
       Float_t ftsize;

       Int_t font  = abs(fTextFont)/10;
       Int_t ifont = font-1;
       if (font > 42 || font < 1) font = 1;
       if (wh < hh) {
          ftsize = fTextSize*fXsize*gPad->GetAbsWNDC();
       } else {
          ftsize = fTextSize*fYsize*gPad->GetAbsHNDC();
       }

       Int_t fontsize = CMtoSVG(ftsize/fontrap);
       if( fontsize <= 0) return;

       if (txalv == 3) iy = iy+fontsize;
       if (txalv == 2) iy = iy+(fontsize/2);

       if (fTextAngle != 0.) {
          PrintFast(21,"<g transform="rotate(");
          WriteInteger(-Int_t(fTextAngle), 0);
          PrintFast(1,",");
          WriteInteger(ix, 0);
          PrintFast(1,",");
          WriteInteger(iy, 0);
          PrintFast(3,")">");
       }

       PrintFast(9,"<text x="");
       WriteInteger(ix, 0);
       PrintFast(5,"" y="");
       WriteInteger(iy, 0);
       PrintFast(1,""");
       if (txalh == 2) {
          PrintFast(21," text-anchor="middle"");
       } else if (txalh == 3) {
          PrintFast(18," text-anchor="end"");
       }
       PrintFast(6," fill=");
       SetColor(Int_t(fTextColor));
       PrintFast(12," font-size="");
       WriteInteger(fontsize, 0);
       PrintFast(15,"" font-family="");
       PrintStr(fontFamily[ifont]);
       if (strcmp(fontWeight[ifont],"normal")) {
          PrintFast(15,"" font-weight="");
          PrintStr(fontWeight[ifont]);
       }
       if (strcmp(fontStyle[ifont],"normal")) {
          PrintFast(14,"" font-style="");
          PrintStr(fontStyle[ifont]);
       }
       PrintFast(2,"">");
       if (font == 12 && chars[0] >= 'xA3' && chars[0] <= 'xF2') {
          char str[8];
          sprintf(str,"&#x%2.2x;", chars[0] & 255);
          PrintStr(str);
       } else {
          PrintStr(chars);
       }
       PrintFast(7,"</text>");

       if (fTextAngle != 0.) PrintFast(4,"</g>");
    }

    //______________________________________________________________________________
     void TSVG::TextNDC(Double_t u, Double_t v, const char *chars)
    {
       // Write a string of characters in NDC

       Double_t x = gPad->GetX1() + u*(gPad->GetX2() - gPad->GetX1());
       Double_t y = gPad->GetY1() + v*(gPad->GetY2() - gPad->GetY1());
       Text(x, y, chars);
    }

    //______________________________________________________________________________
     Int_t TSVG::UtoSVG(Double_t u)
    {
       // Convert U from NDC coordinate to SVG

       Double_t cm = fXsize*(gPad->GetAbsXlowNDC() + u*gPad->GetAbsWNDC());
       return Int_t(0.5 + 72*cm/2.54);
    }

    //______________________________________________________________________________
     Int_t TSVG::VtoSVG(Double_t v)
    {
       // Convert V from NDC coordinate to SVG

       Double_t cm = fYsize*(gPad->GetAbsYlowNDC() + v*gPad->GetAbsHNDC());
       return Int_t(0.5 + 72*cm/2.54);
    }

    //______________________________________________________________________________
     Int_t TSVG::XtoSVG(Double_t x)
    {
       // Convert X from world coordinate to SVG

       Double_t u = (x - gPad->GetX1())/(gPad->GetX2() - gPad->GetX1());
       return  UtoSVG(u);
    }

    //______________________________________________________________________________
     Int_t TSVG::YtoSVG(Double_t y)
    {
       // Convert Y from world coordinate to SVG

       Double_t v = (y - gPad->GetY1())/(gPad->GetY2() - gPad->GetY1());
       return  fYsizeSVG-VtoSVG(v);
    }

    //______________________________________________________________________________
     void TSVG::CellArrayBegin(Int_t, Int_t, Double_t, Double_t, Double_t,
                              Double_t)
    {
       Warning("TSVG::CellArrayBegin", "not yet implemented");
    }

    //______________________________________________________________________________
     void TSVG::CellArrayFill(Int_t, Int_t, Int_t)
    {
       Warning("TSVG::CellArrayFill", "not yet implemented");
    }

    //______________________________________________________________________________
     void TSVG::CellArrayEnd()
    {
       Warning("TSVG::CellArrayEnd", "not yet implemented");
    }

    //______________________________________________________________________________
     void TSVG::DrawPolyMarker(Int_t, Float_t *, Float_t *)
    {
       Warning("TSVG::DrawPolyMarker", "not yet implemented");
    }

    //______________________________________________________________________________
     void TSVG::DrawPolyMarker(Int_t, Double_t *, Double_t *)
    {
       Warning("TSVG::DrawPolyMarker", "not yet implemented");
    }

    //______________________________________________________________________________
     void TSVG::DrawPS(Int_t, Float_t *, Float_t *)
    {
       Warning("TSVG::DrawPS", "not yet implemented");
    }