// @(#)root/gl:$Id$
// Author:  Richard Maunder  25/05/2005

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

#include <algorithm>
#include <cassert>
#include <string>
#include <map>

#include "THLimitsFinder.h"
#include "TVirtualPad.h"
#include "TVirtualX.h"
#include "Riostream.h"
#include "TStyle.h"
#include "TGaxis.h"
#include "TColor.h"
#include "TError.h"
#include "TH1.h"
#include "TMath.h"
#include "TROOT.h"
#include "TClass.h"
#include "TEnv.h"

#include "TGLBoundingBox.h"
#include "TGLCamera.h"
#include "TGLPlotPainter.h"
#include "TGLIncludes.h"
#include "TGLQuadric.h"
#include "TGLUtil.h"

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLVertex3                                                           //
//                                                                      //
// 3 component (x/y/z) vertex class                                     //
//                                                                      //
// This is part of collection of simple utility classes for GL only in  //
// TGLUtil.h/cxx. These provide const and non-const accessors Arr() &   //
// CArr() to a GL compatible internal field - so can be used directly   //
// with OpenGL C API calls - which TVector3 etc cannot (easily).        //
// They are not intended to be fully featured just provide minimum      //
// required.                                                            //
//////////////////////////////////////////////////////////////////////////

ClassImp(TGLVertex3);

//______________________________________________________________________________
TGLVertex3::TGLVertex3()
{
   // Construct a default (0.0, 0.0, 0.0) vertex
   Fill(0.0);
}

//______________________________________________________________________________
TGLVertex3::TGLVertex3(Double_t x, Double_t y, Double_t z)
{
   // Construct a vertex with components (x,y,z)
   Set(x,y,z);
}

//______________________________________________________________________________
TGLVertex3::TGLVertex3(Double_t* v)
{
   // Construct a vertex with components (v[0], v[1], v[2])
   Set(v[0], v[1], v[2]);
}

//______________________________________________________________________________
TGLVertex3::TGLVertex3(const TGLVertex3 & other)
{
   // Construct a vertex from 'other'
   Set(other);
}

//______________________________________________________________________________
TGLVertex3::~TGLVertex3()
{
   // Destroy vertex object
}

//______________________________________________________________________________
void TGLVertex3::Shift(TGLVector3 & shift)
{
   // Offset a vertex by vector 'shift'
   fVals[0] += shift[0];
   fVals[1] += shift[1];
   fVals[2] += shift[2];
}

//______________________________________________________________________________
void TGLVertex3::Shift(Double_t xDelta, Double_t yDelta, Double_t zDelta)
{
   // Offset a vertex by components (xDelta, yDelta, zDelta)
   fVals[0] += xDelta;
   fVals[1] += yDelta;
   fVals[2] += zDelta;
}

//______________________________________________________________________________
void TGLVertex3::Minimum(const TGLVertex3 & other)
{
   fVals[0] = TMath::Min(fVals[0], other.fVals[0]);
   fVals[1] = TMath::Min(fVals[1], other.fVals[1]);
   fVals[2] = TMath::Min(fVals[2], other.fVals[2]);
}

//______________________________________________________________________________
void TGLVertex3::Maximum(const TGLVertex3 & other)
{
   fVals[0] = TMath::Max(fVals[0], other.fVals[0]);
   fVals[1] = TMath::Max(fVals[1], other.fVals[1]);
   fVals[2] = TMath::Max(fVals[2], other.fVals[2]);
}

//______________________________________________________________________________
void TGLVertex3::Dump() const
{
   // Output vertex component values to std::cout
   std::cout << "(" << fVals[0] << "," << fVals[1] << "," << fVals[2] << ")" << std::endl;
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLVector3                                                           //
//                                                                      //
// 3 component (x/y/z) vector class                                     //
//                                                                      //
// This is part of collection of utility classes for GL in TGLUtil.h/cxx//
// These provide const and non-const accessors Arr() / CArr() to a GL   //
// compatible internal field - so can be used directly with OpenGL C API//
// calls. They are not intended to be fully featured just provide       //
// minimum required.                                                    //
//////////////////////////////////////////////////////////////////////////

ClassImp(TGLVector3);

//______________________________________________________________________________
TGLVector3::TGLVector3() :
   TGLVertex3()
{
   // Construct a default (0.0, 0.0, 0.0) vector
}

//______________________________________________________________________________
TGLVector3::TGLVector3(Double_t x, Double_t y, Double_t z) :
   TGLVertex3(x, y, z)
{
   // Construct a vector with components (x,y,z)
}

//______________________________________________________________________________
TGLVector3::TGLVector3(const TGLVector3 & other) :
   TGLVertex3(other.fVals[0], other.fVals[1], other.fVals[2])
{
   // Construct a vector from components of 'other'
}

//______________________________________________________________________________
TGLVector3::TGLVector3(const Double_t *src) :
   TGLVertex3(src[0], src[1], src[2])
{
   // Construct a vector with components (src[0], src[1], src[2])
}

//______________________________________________________________________________
TGLVector3::~TGLVector3()
{
   // Destroy vector object
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLLine3                                                             //
//                                                                      //
// 3D space, fixed length, line class, with direction / length 'vector',//
// passing through point 'vertex'. Just wraps a TGLVector3 / TGLVertex3 //
// pair.                                                                //
//////////////////////////////////////////////////////////////////////////

ClassImp(TGLLine3);

//______________________________________________________________________________
TGLLine3::TGLLine3(const TGLVertex3 & start, const TGLVertex3 & end) :
   fVertex(start), fVector(end - start)
{
   // Construct 3D line running from 'start' to 'end'
}

//______________________________________________________________________________
TGLLine3::TGLLine3(const TGLVertex3 & start, const TGLVector3 & vect) :
   fVertex(start), fVector(vect)
{
   // Construct 3D line running from 'start', magnitude 'vect'
}

//______________________________________________________________________________
TGLLine3::~TGLLine3()
{
   // Destroy 3D line object
}

//______________________________________________________________________________
void TGLLine3::Set(const TGLVertex3 & start, const TGLVertex3 & end)
{
   // Set 3D line running from 'start' to 'end'

   fVertex = start;
   fVector = end - start;
}

//______________________________________________________________________________
void TGLLine3::Set(const TGLVertex3 & start, const TGLVector3 & vect)
{
   // Set 3D line running from start, magnitude 'vect'
   fVertex = start;
   fVector = vect;
}

//______________________________________________________________________________
void TGLLine3::Draw() const
{
   // Draw line in current basic GL color. Assume we are in the correct reference
   // frame
   glBegin(GL_LINE_LOOP);
   glVertex3dv(fVertex.CArr());
   glVertex3dv(End().CArr());
   glEnd();
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLRect                                                              //
//                                                                      //
// Viewport (pixel base) 2D rectangle class                             //
//////////////////////////////////////////////////////////////////////////

ClassImp(TGLRect);

//______________________________________________________________________________
TGLRect::TGLRect() :
      fX(0), fY(0), fWidth(0), fHeight(0)
{
   // Construct empty rect object, corner (0,0), width/height 0
}

//______________________________________________________________________________
TGLRect::TGLRect(Int_t x, Int_t y, Int_t width, Int_t height) :
      fX(x), fY(y), fWidth(width), fHeight(height)
{
   // Construct rect object, corner (x,y), dimensions 'width', 'height'
}

//______________________________________________________________________________
TGLRect::TGLRect(Int_t x, Int_t y, UInt_t width, UInt_t height) :
      fX(x), fY(y), fWidth(width), fHeight(height)
{
   // Construct rect object, corner (x,y), dimensions 'width', 'height'
}


//______________________________________________________________________________
TGLRect::~TGLRect()
{
   // Destroy rect object
}

//______________________________________________________________________________
void TGLRect::Expand(Int_t x, Int_t y)
{
   // Expand the rect to encompass point (x,y)
   Int_t delX = x - fX;
   Int_t delY = y - fY;

   if (delX > fWidth) {
      fWidth = delX;
   }
   if (delY > fHeight) {
      fHeight = delY;
   }

   if (delX < 0) {
      fX = x;
      fWidth += -delX;
   }
   if (delY < 0) {
      fY = y;
      fHeight += -delY;
   }
}

//______________________________________________________________________________
Int_t TGLRect::Diagonal() const
{
   // Return the diagonal of the rectangle.

   const Double_t w = static_cast<Double_t>(fWidth);
   const Double_t h = static_cast<Double_t>(fHeight);
   return TMath::Nint(TMath::Sqrt(w*w + h*h));
}

//______________________________________________________________________________
Rgl::EOverlap TGLRect::Overlap(const TGLRect & other) const
{
   // Return overlap result (kInside, kOutside, kPartial) of this
   // rect with 'other'

   using namespace Rgl;

   if ((fX <= other.fX) && (fX + fWidth  >= other.fX + other.fWidth) &&
       (fY <= other.fY) && (fY + fHeight >= other.fY + other.fHeight))
   {
      return kInside;
   }
   else if ((fX >= other.fX + static_cast<Int_t>(other.fWidth))  ||
            (fX + static_cast<Int_t>(fWidth) <= other.fX)        ||
            (fY >= other.fY + static_cast<Int_t>(other.fHeight)) ||
            (fY + static_cast<Int_t>(fHeight) <= other.fY))
   {
      return kOutside;
   }
   else
   {
      return kPartial;
   }
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLPlane                                                             //
//                                                                      //
// 3D plane class - of format Ax + By + Cz + D = 0                      //
//                                                                      //
// This is part of collection of simple utility classes for GL only in  //
// TGLUtil.h/cxx. These provide const and non-const accessors Arr() &   //
// CArr() to a GL compatible internal field - so can be used directly   //
// with OpenGL C API calls - which TVector3 etc cannot (easily).        //
// They are not intended to be fully featured just provide minimum      //
// required.                                                            //
//////////////////////////////////////////////////////////////////////////

ClassImp(TGLPlane);

//______________________________________________________________________________
TGLPlane::TGLPlane()
{
   // Construct a default plane of x + y + z = 0
   Set(1.0, 1.0, 1.0, 0.0);
}

//______________________________________________________________________________
TGLPlane::TGLPlane(const TGLPlane & other)
{
   // Construct plane from 'other'
   Set(other);
}

//______________________________________________________________________________
TGLPlane::TGLPlane(Double_t a, Double_t b, Double_t c, Double_t d)
{
   // Construct plane with equation a.x + b.y + c.z + d = 0
   // with optional normalisation
   Set(a, b, c, d);
}

//______________________________________________________________________________
TGLPlane::TGLPlane(Double_t eq[4])
{
   // Construct plane with equation eq[0].x + eq[1].y + eq[2].z + eq[3] = 0
   // with optional normalisation
   Set(eq);
}

//______________________________________________________________________________
TGLPlane::TGLPlane(const TGLVertex3 & p1, const TGLVertex3 & p2,
                   const TGLVertex3 & p3)
{
   // Construct plane passing through 3 supplied points
   // with optional normalisation
   Set(p1, p2, p3);
}

//______________________________________________________________________________
TGLPlane::TGLPlane(const TGLVector3 & v, const TGLVertex3 & p)
{
   // Construct plane with supplied normal vector, passing through point
   // with optional normalisation
   Set(v, p);
}

//______________________________________________________________________________
TGLPlane::~TGLPlane()
{
   // Destroy plane object
}

//______________________________________________________________________________
void TGLPlane::Normalise()
{
   // Normalise the plane.

   Double_t mag = sqrt(fVals[0]*fVals[0] + fVals[1]*fVals[1] + fVals[2]*fVals[2]);

   if (mag == 0.0 ) {
      Error("TGLPlane::Normalise", "trying to normalise plane with zero magnitude normal");
      return;
   }
   mag = 1.0 / mag;
   fVals[0] *= mag;
   fVals[1] *= mag;
   fVals[2] *= mag;
   fVals[3] *= mag;
}

//______________________________________________________________________________
void TGLPlane::Dump() const
{
   // Output plane equation to std::out

   std::cout.precision(6);
   std::cout << "Plane : " << fVals[0] << "x + " << fVals[1] << "y + " << fVals[2] << "z + " << fVals[3] << std::endl;
}

//______________________________________________________________________________
void TGLPlane::Set(const TGLPlane & other)
{
   // Assign from other.

   fVals[0] = other.fVals[0];
   fVals[1] = other.fVals[1];
   fVals[2] = other.fVals[2];
   fVals[3] = other.fVals[3];
}

//______________________________________________________________________________
void TGLPlane::Set(Double_t a, Double_t b, Double_t c, Double_t d)
{
   // Set by values.

   fVals[0] = a;
   fVals[1] = b;
   fVals[2] = c;
   fVals[3] = d;
   Normalise();
}

//______________________________________________________________________________
void TGLPlane::Set(Double_t eq[4])
{
   // Set by array values.

   fVals[0] = eq[0];
   fVals[1] = eq[1];
   fVals[2] = eq[2];
   fVals[3] = eq[3];
   Normalise();
}

//______________________________________________________________________________
void TGLPlane::Set(const TGLVector3 & norm, const TGLVertex3 & point)
{
   // Set plane from a normal vector and in-plane point pair

   fVals[0] = norm[0];
   fVals[1] = norm[1];
   fVals[2] = norm[2];
   fVals[3] = -(fVals[0]*point[0] + fVals[1]*point[1] + fVals[2]*point[2]);
   Normalise();
}

//______________________________________________________________________________
void TGLPlane::Set(const TGLVertex3 & p1, const TGLVertex3 & p2, const TGLVertex3 & p3)
{
   // Set plane by three points.

   TGLVector3 norm = Cross(p2 - p1, p3 - p1);
   Set(norm, p2);
}

//______________________________________________________________________________
void TGLPlane::Negate()
{
   // Negate the plane.

   fVals[0] = -fVals[0];
   fVals[1] = -fVals[1];
   fVals[2] = -fVals[2];
   fVals[3] = -fVals[3];
}

//______________________________________________________________________________
Double_t TGLPlane::DistanceTo(const TGLVertex3 & vertex) const
{
   // Distance from plane to vertex.

   return (fVals[0]*vertex[0] + fVals[1]*vertex[1] + fVals[2]*vertex[2] + fVals[3]);
}

//______________________________________________________________________________
TGLVertex3 TGLPlane::NearestOn(const TGLVertex3 & point) const
{
   // Return nearest point on plane.

   TGLVector3 o = Norm() * (Dot(Norm(), TGLVector3(point[0], point[1], point[2])) + D() / Dot(Norm(), Norm()));
   TGLVertex3 v = point - o;
   return v;
}

// Some free functions for plane intersections

//______________________________________________________________________________
std::pair<Bool_t, TGLLine3> Intersection(const TGLPlane & p1, const TGLPlane & p2)
{
   // Find 3D line interestion of this plane with 'other'. Returns a std::pair
   //
   // first (Bool_t)                   second (TGLLine3)
   // kTRUE - planes intersect         intersection line between planes
   // kFALSE - no intersect (parallel) undefined
   TGLVector3 lineDir = Cross(p1.Norm(), p2.Norm());

   if (lineDir.Mag() == 0.0) {
      return std::make_pair(kFALSE, TGLLine3(TGLVertex3(0.0, 0.0, 0.0),
                                             TGLVector3(0.0, 0.0, 0.0)));
   }
   TGLVertex3 linePoint = Cross((p1.Norm()*p2.D() - p2.Norm()*p1.D()), lineDir) /
                           Dot(lineDir, lineDir);
   return std::make_pair(kTRUE, TGLLine3(linePoint, lineDir));
}

//______________________________________________________________________________
std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & p1, const TGLPlane & p2, const TGLPlane & p3)
{
   Double_t denom = Dot(p1.Norm(), Cross(p2.Norm(), p3.Norm()));
   if (denom == 0.0) {
      return std::make_pair(kFALSE, TGLVertex3(0.0, 0.0, 0.0));
   }
   TGLVector3 vect = ((Cross(p2.Norm(),p3.Norm())* -p1.D()) -
                      (Cross(p3.Norm(),p1.Norm())*p2.D()) -
                      (Cross(p1.Norm(),p2.Norm())*p3.D())) / denom;
   TGLVertex3 interVert(vect.X(), vect.Y(), vect.Z());
   return std::make_pair(kTRUE, interVert);
}

//______________________________________________________________________________
std::pair<Bool_t, TGLVertex3> Intersection(const TGLPlane & plane, const TGLLine3 & line, Bool_t extend)
{
   // Find intersection of 3D space 'line' with this plane. If 'extend' is kTRUE
   // then line extents can be extended (infinite length) to find intersection.
   // If 'extend' is kFALSE the fixed extents of line is respected.
   //
   // The return a std::pair
   //
   // first (Bool_t)                   second (TGLVertex3)
   // kTRUE - line/plane intersect     intersection vertex on plane
   // kFALSE - no line/plane intersect undefined
   //
   // If intersection is not found (first == kFALSE) & 'extend' was kTRUE (infinite line)
   // this implies line and plane are parallel. If 'extend' was kFALSE, then
   // either line parallel or insuffient length.
   Double_t denom = -(plane.A()*line.Vector().X() +
                      plane.B()*line.Vector().Y() +
                      plane.C()*line.Vector().Z());

   if (denom == 0.0) {
      return std::make_pair(kFALSE, TGLVertex3(0.0, 0.0, 0.0));
   }

   Double_t num = plane.A()*line.Start().X() + plane.B()*line.Start().Y() +
                  plane.C()*line.Start().Z() + plane.D();
   Double_t factor = num/denom;

   // If not extending (projecting) line is length from start enough to reach plane?
   if (!extend && (factor < 0.0 || factor > 1.0)) {
      return std::make_pair(kFALSE, TGLVertex3(0.0, 0.0, 0.0));
   }

   TGLVector3 toPlane = line.Vector() * factor;
   return std::make_pair(kTRUE, line.Start() + toPlane);
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGLMatrix                                                            //
//                                                                      //
// 16 component (4x4) transform matrix - column MAJOR as per GL.        //
// Provides limited support for adjusting the translation, scale and    //
// rotation components.                                                 //
//                                                                      //
// This is part of collection of simple utility classes for GL only in  //
// TGLUtil.h/cxx. These provide const and non-const accessors Arr() &   //
// CArr() to a GL compatible internal field - so can be used directly   //
// with OpenGL C API calls - which TVector3 etc cannot (easily).        //
// They are not intended to be fully featured just provide minimum      //
// required.                                                            //
//////////////////////////////////////////////////////////////////////////

ClassImp(TGLMatrix);

//______________________________________________________________________________
TGLMatrix::TGLMatrix()
{
   // Construct default identity matrix:
   //
   // 1 0 0 0
   // 0 1 0 0
   // 0 0 1 0
   // 0 0 0 1
   SetIdentity();
}

//______________________________________________________________________________
TGLMatrix::TGLMatrix(Double_t x, Double_t y, Double_t z)
{
   // Construct matrix with translation components x,y,z:
   //
   // 1 0 0 x
   // 0 1 0 y
   // 0 0 1 z
   // 0 0 0 1
   SetIdentity();
   SetTranslation(x, y, z);
}

//______________________________________________________________________________
TGLMatrix::TGLMatrix(const TGLVertex3 & translation)
{
   // Construct matrix with translation components x,y,z:
   //
   // 1 0 0 translation.X()
   // 0 1 0 translation.Y()
   // 0 0 1 translation.Z()
   // 0 0 0 1
   SetIdentity();
   SetTranslation(translation);
}

//______________________________________________________________________________
TGLMatrix::TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis)
{
   // Construct matrix which when applied puts local origin at
   // 'origin' and the local Z axis in direction 'z'. Both
   // 'origin' and 'zAxisVec' are expressed in the parent frame
   SetIdentity();

   TGLVector3 zAxisInt(zAxis);
   zAxisInt.Normalise();
   TGLVector3 arbAxis;

   if (TMath::Abs(zAxisInt.X()) <= TMath::Abs(zAxisInt.Y()) && TMath::Abs(zAxisInt.X()) <= TMath::Abs(zAxisInt.Z())) {
      arbAxis.Set(1.0, 0.0, 0.0);
   } else if (TMath::Abs(zAxisInt.Y()) <= TMath::Abs(zAxisInt.X()) && TMath::Abs(zAxisInt.Y()) <= TMath::Abs(zAxisInt.Z())) {
      arbAxis.Set(0.0, 1.0, 0.0);
   } else {
      arbAxis.Set(0.0, 0.0, 1.0);
   }

   Set(origin, zAxis, Cross(zAxisInt, arbAxis));
}

//______________________________________________________________________________
TGLMatrix::TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis)
{
   // Construct matrix which when applied puts local origin at
   // 'origin' and the local Z axis in direction 'z'. Both
   // 'origin' and 'zAxisVec' are expressed in the parent frame
   SetIdentity();
   Set(origin, zAxis, xAxis);
}

//______________________________________________________________________________
TGLMatrix::TGLMatrix(const Double_t vals[16])
{
   // Construct matrix using the 16 Double_t 'vals' passed,
   // ordering is maintained - i.e. should be column major
   // as we are
   Set(vals);
}

//______________________________________________________________________________
TGLMatrix::TGLMatrix(const TGLMatrix & other)
{
   // Construct matrix from 'other'
   *this = other;
}

//______________________________________________________________________________
TGLMatrix::~TGLMatrix()
{
   // Destroy matirx object
}

//______________________________________________________________________________
void TGLMatrix::MultRight(const TGLMatrix & rhs)
{
   // Multiply with matrix rhs on right.

  Double_t  B[4];
  Double_t* C = fVals;
  for(int r=0; r<4; ++r, ++C)
  {
    const Double_t* T = rhs.fVals;
    for(int c=0; c<4; ++c, T+=4)
      B[c] = C[0]*T[0] + C[4]*T[1] + C[8]*T[2] + C[12]*T[3];
    C[0] = B[0]; C[4] = B[1]; C[8] = B[2]; C[12] = B[3];
  }
}

//______________________________________________________________________________
void TGLMatrix::MultLeft (const TGLMatrix & lhs)
{
   // Multiply with matrix lhs on left.

   Double_t  B[4];
   Double_t* C = fVals;
   for (int c=0; c<4; ++c, C+=4)
   {
      const Double_t* T = lhs.fVals;
      for(int r=0; r<4; ++r, ++T)
         B[r] = T[0]*C[0] + T[4]*C[1] + T[8]*C[2] + T[12]*C[3];
      C[0] = B[0]; C[1] = B[1]; C[2] = B[2]; C[3] = B[3];
   }
}

//______________________________________________________________________________
void TGLMatrix::Set(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis)
{
   // Set matrix which when applied puts local origin at
   // 'origin' and the local Z axis in direction 'z'. Both
   // 'origin' and 'z' are expressed in the parent frame
   TGLVector3 zAxisInt(zAxis);
   zAxisInt.Normalise();

   TGLVector3 xAxisInt(xAxis);
   xAxisInt.Normalise();
   TGLVector3 yAxisInt = Cross(zAxisInt, xAxisInt);

   fVals[0] = xAxisInt.X(); fVals[4] = yAxisInt.X(); fVals[8 ] = zAxisInt.X(); fVals[12] = origin.X();
   fVals[1] = xAxisInt.Y(); fVals[5] = yAxisInt.Y(); fVals[9 ] = zAxisInt.Y(); fVals[13] = origin.Y();
   fVals[2] = xAxisInt.Z(); fVals[6] = yAxisInt.Z(); fVals[10] = zAxisInt.Z(); fVals[14] = origin.Z();
   fVals[3] = 0.0;          fVals[7] = 0.0;          fVals[11] = 0.0;          fVals[15] = 1.0;
}

//______________________________________________________________________________
void TGLMatrix::Set(const Double_t vals[16])
{
   // Set matrix using the 16 Double_t 'vals' passed,
   // ordering is maintained - i.e. should be column major.

   for (UInt_t i=0; i < 16; i++) {
      fVals[i] = vals[i];
   }
}

//______________________________________________________________________________
void TGLMatrix::SetIdentity()
{
   // Set matrix to identity.

   fVals[0] = 1.0; fVals[4] = 0.0; fVals[8 ] = 0.0; fVals[12] = 0.0;
   fVals[1] = 0.0; fVals[5] = 1.0; fVals[9 ] = 0.0; fVals[13] = 0.0;
   fVals[2] = 0.0; fVals[6] = 0.0; fVals[10] = 1.0; fVals[14] = 0.0;
   fVals[3] = 0.0; fVals[7] = 0.0; fVals[11] = 0.0; fVals[15] = 1.0;
}

//______________________________________________________________________________
void TGLMatrix::SetTranslation(Double_t x, Double_t y, Double_t z)
{
   // Set matrix translation components x,y,z.

   SetTranslation(TGLVertex3(x,y,z));
}

//______________________________________________________________________________
void TGLMatrix::SetTranslation(const TGLVertex3 & translation)
{
   // Set matrix translation components x,y,z.

   fVals[12] = translation[0];
   fVals[13] = translation[1];
   fVals[14] = translation[2];
}

//______________________________________________________________________________
TGLVector3 TGLMatrix::GetTranslation() const
{
   // Return the translation component of matrix.

   return TGLVector3(fVals[12], fVals[13], fVals[14]);
}

//______________________________________________________________________________
void TGLMatrix::Translate(const TGLVector3 & vect)
{
   // Shift matrix translation components by 'vect' in parent frame.

   fVals[12] += vect[0];
   fVals[13] += vect[1];
   fVals[14] += vect[2];
}

//______________________________________________________________________________
void TGLMatrix::MoveLF(Int_t ai, Double_t amount)
{
   // Translate in local frame.
   // i1, i2 are axes indices: 1 ~ x, 2 ~ y, 3 ~ z.

   const Double_t *C = fVals + 4*--ai;
   fVals[12] += amount*C[0]; fVals[13] += amount*C[1]; fVals[14] += amount*C[2];
}

//______________________________________________________________________________
void TGLMatrix::Move3LF(Double_t x, Double_t y, Double_t z)
{
   // Translate in local frame along all base vectors simultaneously.

   fVals[12] += x*fVals[0] + y*fVals[4] + z*fVals[8];
   fVals[13] += x*fVals[1] + y*fVals[5] + z*fVals[9];
   fVals[14] += x*fVals[2] + y*fVals[6] + z*fVals[10];
}

//______________________________________________________________________________
void TGLMatrix::Scale(const TGLVector3 & scale)
{
   // Set matrix axis scales to 'scale'. Note - this really sets
   // the overall (total) scaling for each axis - it does NOT
   // apply compounded scale on top of existing one
   TGLVector3 currentScale = GetScale();

   // x
   if (currentScale[0] != 0.0) {
      fVals[0] *= scale[0]/currentScale[0];
      fVals[1] *= scale[0]/currentScale[0];
      fVals[2] *= scale[0]/currentScale[0];
   } else {
      Error("TGLMatrix::Scale()", "zero scale div by zero");
   }
   // y
   if (currentScale[1] != 0.0) {
      fVals[4] *= scale[1]/currentScale[1];
      fVals[5] *= scale[1]/currentScale[1];
      fVals[6] *= scale[1]/currentScale[1];
   } else {
      Error("TGLMatrix::Scale()", "zero scale div by zero");
   }
   // z
   if (currentScale[2] != 0.0) {
      fVals[8] *= scale[2]/currentScale[2];
      fVals[9] *= scale[2]/currentScale[2];
      fVals[10] *= scale[2]/currentScale[2];
   } else {
      Error("TGLMatrix::Scale()", "zero scale div by zero");
   }
}

//______________________________________________________________________________
void TGLMatrix::Rotate(const TGLVertex3 & pivot, const TGLVector3 & axis, Double_t angle)
{
   // Update martix so resulting transform has been rotated about 'pivot'
   // (in parent frame), round vector 'axis', through 'angle' (radians)
   // Equivalent to glRotate function, but with addition of translation
   // and compounded on top of existing.
   TGLVector3 nAxis = axis;
   nAxis.Normalise();
   Double_t x = nAxis.X();
   Double_t y = nAxis.Y();
   Double_t z = nAxis.Z();
   Double_t c = TMath::Cos(angle);
   Double_t s = TMath::Sin(angle);

   // Calculate local rotation, with pre-translation to local pivot origin
   TGLMatrix rotMat;
   rotMat[ 0] = x*x*(1-c) + c;   rotMat[ 4] = x*y*(1-c) - z*s; rotMat[ 8] = x*z*(1-c) + y*s; rotMat[12] = pivot[0];
   rotMat[ 1] = y*x*(1-c) + z*s; rotMat[ 5] = y*y*(1-c) + c;   rotMat[ 9] = y*z*(1-c) - x*s; rotMat[13] = pivot[1];
   rotMat[ 2] = x*z*(1-c) - y*s; rotMat[ 6] = y*z*(1-c) + x*s; rotMat[10] = z*z*(1-c) + c;   rotMat[14] = pivot[2];
   rotMat[ 3] = 0.0;             rotMat[ 7] = 0.0;             rotMat[11] = 0.0;             rotMat[15] = 1.0;
   TGLMatrix localToWorld(-pivot);

   // TODO: Ugly - should use quaternions to avoid compound rounding errors and
   // triple multiplication
   *this = rotMat * localToWorld * (*this);
}

//______________________________________________________________________________
void TGLMatrix::RotateLF(Int_t i1, Int_t i2, Double_t amount)
{
   // Rotate in local frame. Does optimised version of MultRight.
   // i1, i2 are axes indices: 1 ~ x, 2 ~ y, 3 ~ z.

   if(i1 == i2) return;
   const Double_t cos = TMath::Cos(amount), sin = TMath::Sin(amount);
   Double_t  b1, b2;
   Double_t* c = fVals;
   --i1 <<= 2; --i2 <<= 2; // column major
   for(int r=0; r<4; ++r, ++c) {
      b1 = cos*c[i1] + sin*c[i2];
      b2 = cos*c[i2] - sin*c[i1];
      c[i1] = b1; c[i2] = b2;
   }
}

//______________________________________________________________________________
void TGLMatrix::RotatePF(Int_t i1, Int_t i2, Double_t amount)
{
   // Rotate in parent frame. Does optimised version of MultLeft.

   if(i1 == i2) return;

   // Optimized version:
   const Double_t cos = TMath::Cos(amount), sin = TMath::Sin(amount);
   Double_t  b1, b2;
   Double_t* C = fVals;
   --i1; --i2;
   for(int c=0; c<4; ++c, C+=4) {
      b1 = cos*C[i1] - sin*C[i2];
      b2 = cos*C[i2] + sin*C[i1];
      C[i1] = b1; C[i2] = b2;
   }
}

//______________________________________________________________________________
void TGLMatrix::TransformVertex(TGLVertex3 & vertex) const
{
   // Transform passed 'vertex' by this matrix - converts local frame to parent
   TGLVertex3 orig = vertex;
   for (UInt_t i = 0; i < 3; i++) {
      vertex[i] = orig[0] * fVals[0+i] + orig[1] * fVals[4+i] +
                  orig[2] * fVals[8+i] + fVals[12+i];
   }
}

//______________________________________________________________________________
void TGLMatrix::Transpose3x3()
{
   // Transpose the top left 3x3 matrix component along major diagonal
   // Supported as currently incompatability between TGeo and GL matrix
   // layouts for this 3x3 only. To be resolved.

   // TODO: Move this fix to the TBuffer3D filling side and remove
   //
   // 0  4  8 12
   // 1  5  9 13
   // 2  6 10 14
   // 3  7 11 15

   Double_t temp = fVals[4];
   fVals[4] = fVals[1];
   fVals[1] = temp;
   temp = fVals[8];
   fVals[8] = fVals[2];
   fVals[2] = temp;
   temp = fVals[9];
   fVals[9] = fVals[6];
   fVals[6] = temp;
}

//______________________________________________________________________________
Double_t TGLMatrix::Invert()
{
   // Invert the matrix, returns determinant.
   // Copied from TMatrixFCramerInv.

   Double_t* M = fVals;

   const Double_t det2_12_01 = M[1]*M[6]  - M[5]*M[2];
   const Double_t det2_12_02 = M[1]*M[10] - M[9]*M[2];
   const Double_t det2_12_03 = M[1]*M[14] - M[13]*M[2];
   const Double_t det2_12_13 = M[5]*M[14] - M[13]*M[6];
   const Double_t det2_12_23 = M[9]*M[14] - M[13]*M[10];
   const Double_t det2_12_12 = M[5]*M[10] - M[9]*M[6];
   const Double_t det2_13_01 = M[1]*M[7]  - M[5]*M[3];
   const Double_t det2_13_02 = M[1]*M[11] - M[9]*M[3];
   const Double_t det2_13_03 = M[1]*M[15] - M[13]*M[3];
   const Double_t det2_13_12 = M[5]*M[11] - M[9]*M[7];
   const Double_t det2_13_13 = M[5]*M[15] - M[13]*M[7];
   const Double_t det2_13_23 = M[9]*M[15] - M[13]*M[11];
   const Double_t det2_23_01 = M[2]*M[7]  - M[6]*M[3];
   const Double_t det2_23_02 = M[2]*M[11] - M[10]*M[3];
   const Double_t det2_23_03 = M[2]*M[15] - M[14]*M[3];
   const Double_t det2_23_12 = M[6]*M[11] - M[10]*M[7];
   const Double_t det2_23_13 = M[6]*M[15] - M[14]*M[7];
   const Double_t det2_23_23 = M[10]*M[15] - M[14]*M[11];


   const Double_t det3_012_012 = M[0]*det2_12_12 - M[4]*det2_12_02 + M[8]*det2_12_01;
   const Double_t det3_012_013 = M[0]*det2_12_13 - M[4]*det2_12_03 + M[12]*det2_12_01;
   const Double_t det3_012_023 = M[0]*det2_12_23 - M[8]*det2_12_03 + M[12]*det2_12_02;
   const Double_t det3_012_123 = M[4]*det2_12_23 - M[8]*det2_12_13 + M[12]*det2_12_12;
   const Double_t det3_013_012 = M[0]*det2_13_12 - M[4]*det2_13_02 + M[8]*det2_13_01;
   const Double_t det3_013_013 = M[0]*det2_13_13 - M[4]*det2_13_03 + M[12]*det2_13_01;
   const Double_t det3_013_023 = M[0]*det2_13_23 - M[8]*det2_13_03 + M[12]*det2_13_02;
   const Double_t det3_013_123 = M[4]*det2_13_23 - M[8]*det2_13_13 + M[12]*det2_13_12;
   const Double_t det3_023_012 = M[0]*det2_23_12 - M[4]*det2_23_02 + M[8]*det2_23_01;
   const Double_t det3_023_013 = M[0]*det2_23_13 - M[4]*det2_23_03 + M[12]*det2_23_01;
   const Double_t det3_023_023 = M[0]*det2_23_23 - M[8]*det2_23_03 + M[12]*det2_23_02;
   const Double_t det3_023_123 = M[4]*det2_23_23 - M[8]*det2_23_13 + M[12]*det2_23_12;
   const Double_t det3_123_012 = M[1]*det2_23_12 - M[5]*det2_23_02 + M[9]*det2_23_01;
   const Double_t det3_123_013 = M[1]*det2_23_13 - M[5]*det2_23_03 + M[13]*det2_23_01;
   const Double_t det3_123_023 = M[1]*det2_23_23 - M[9]*det2_23_03 + M[13]*det2_23_02;
   const Double_t det3_123_123 = M[5]*det2_23_23 - M[9]*det2_23_13 + M[13]*det2_23_12;

   const Double_t det = M[0]*det3_123_123 - M[4]*det3_123_023 +
      M[8]*det3_123_013 - M[12]*det3_123_012;

   if(det == 0) {
      Warning("TGLMatrix::Invert", "matrix is singular.");
      return 0;
   }

   const Double_t oneOverDet = 1.0/det;
   const Double_t mn1OverDet = - oneOverDet;

   M[0]  = det3_123_123 * oneOverDet;
   M[4]  = det3_023_123 * mn1OverDet;
   M[8]  = det3_013_123 * oneOverDet;
   M[12] = det3_012_123 * mn1OverDet;

   M[1]  = det3_123_023 * mn1OverDet;
   M[5]  = det3_023_023 * oneOverDet;
   M[9]  = det3_013_023 * mn1OverDet;
   M[13] = det3_012_023 * oneOverDet;

   M[2]  = det3_123_013 * oneOverDet;
   M[6]  = det3_023_013 * mn1OverDet;
   M[10] = det3_013_013 * oneOverDet;
   M[14] = det3_012_013 * mn1OverDet;

   M[3]  = det3_123_012 * mn1OverDet;
   M[7]  = det3_023_012 * oneOverDet;
   M[11] = det3_013_012 * mn1OverDet;
   M[15] = det3_012_012 * oneOverDet;

   return det;
}

//______________________________________________________________________________
TGLVector3 TGLMatrix::Multiply(const TGLVector3& v, Double_t w) const
{
   // Multiply vector.
   const Double_t* M = fVals;
   TGLVector3 r;
   r.X() = M[0]*v[0] + M[4]*v[1] +  M[8]*v[2] + M[12]*w;
   r.Y() = M[1]*v[0] + M[5]*v[1] +  M[9]*v[2] + M[13]*w;
   r.Z() = M[2]*v[0] + M[6]*v[1] + M[10]*v[2] + M[14]*w;
   return r;
}

//______________________________________________________________________________
TGLVector3 TGLMatrix::Rotate(const TGLVector3& v) const
{
   // Rotate vector. Translation is not applied.
   const Double_t* M = fVals;
   TGLVector3 r;
   r.X() = M[0]*v[0] + M[4]*v[1] +  M[8]*v[2];
   r.Y() = M[1]*v[0] + M[5]*v[1] +  M[9]*v[2];
   r.Z() = M[2]*v[0] + M[6]*v[1] + M[10]*v[2];
   return r;
}

//______________________________________________________________________________
void TGLMatrix::MultiplyIP(TGLVector3& v, Double_t w) const
{
   // Multiply vector in-place.
   const Double_t* M = fVals;
   Double_t r[3] = { v[0], v[1], v[2] };
   v.X() = M[0]*r[0] + M[4]*r[1] +  M[8]*r[2] + M[12]*w;
   v.Y() = M[1]*r[0] + M[5]*r[1] +  M[9]*r[2] + M[13]*w;
   v.Z() = M[2]*r[0] + M[6]*r[1] + M[10]*r[2] + M[14]*w;
}

//______________________________________________________________________________
void TGLMatrix::RotateIP(TGLVector3& v) const
{
   // Rotate vector in-place. Translation is not applied.
   const Double_t* M = fVals;
   Double_t r[3] = { v[0], v[1], v[2] };
   v.X() = M[0]*r[0] + M[4]*r[1] +  M[8]*r[2];
   v.Y() = M[1]*r[0] + M[5]*r[1] +  M[9]*r[2];
   v.Z() = M[2]*r[0] + M[6]*r[1] + M[10]*r[2];
}

//______________________________________________________________________________
TGLVector3 TGLMatrix::GetScale() const
{
   // Get local axis scaling factors
   TGLVector3 x(fVals[0], fVals[1], fVals[2]);
   TGLVector3 y(fVals[4], fVals[5], fVals[6]);
   TGLVector3 z(fVals[8], fVals[9], fVals[10]);
   return TGLVector3(x.Mag(), y.Mag(), z.Mag());
}

//______________________________________________________________________________
Bool_t TGLMatrix::IsScalingForRender() const
{
   // Return true if matrix is to be considered a scaling matrix
   // for rendering.
   Double_t ss;
   ss = fVals[0]*fVals[0] + fVals[1]*fVals[1] + fVals[2]*fVals[2];
   if (ss < 0.8 || ss > 1.2) return kTRUE;
   ss = fVals[4]*fVals[4] + fVals[5]*fVals[5] + fVals[6]*fVals[6];
   if (ss < 0.8 || ss > 1.2) return kTRUE;
   ss = fVals[8]*fVals[8] + fVals[9]*fVals[9] + fVals[10]*fVals[10];
   if (ss < 0.8 || ss > 1.2) return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
void TGLMatrix::Dump() const
{
   // Output 16 matrix components to std::cout
   //
   // 0  4   8  12
   // 1  5   9  13
   // 2  6  10  14
   // 3  7  11  15
   //
   std::cout.precision(6);
   for (Int_t x = 0; x < 4; x++) {
      std::cout << "[ ";
      for (Int_t y = 0; y < 4; y++) {
         std::cout << fVals[y*4 + x] << " ";
      }
      std::cout << "]" << std::endl;
   }
}


//==============================================================================
// TGLColor
//==============================================================================

//______________________________________________________________________________
//
// Class encapsulating color information in preferred GL format - an
// array of four unsigned bytes.
// Color index is also cached for easier interfacing with the
// traditional ROOT graphics.
//

ClassImp(TGLColor);

//______________________________________________________________________________
TGLColor::TGLColor()
{
   // Default constructor. Color is initialized to black.

   fRGBA[0] = fRGBA[1] = fRGBA[2] = 0;
   fRGBA[3] = 255;
   fIndex   = -1;
}

//______________________________________________________________________________
TGLColor::TGLColor(Int_t r, Int_t g, Int_t b, Int_t a)
{
   // Constructor from Int_t values.

   SetColor(r, g, b, a);
}

//______________________________________________________________________________
TGLColor::TGLColor(Float_t r, Float_t g, Float_t b, Float_t a)
{
   // Constructor from Float_t values.

   SetColor(r, g, b, a);
}

//______________________________________________________________________________
TGLColor::TGLColor(Color_t color_index, Char_t transparency)
{
   // Constructor from color-index and transparency.

   SetColor(color_index, transparency);
}

//______________________________________________________________________________
TGLColor::~TGLColor()
{
   // Dectructor.
}

//______________________________________________________________________________
TGLColor& TGLColor::operator=(const TGLColor& c)
{
   // Assignment operator.

   fRGBA[0] = c.fRGBA[0];
   fRGBA[1] = c.fRGBA[1];
   fRGBA[2] = c.fRGBA[2];
   fRGBA[3] = c.fRGBA[3];
   fIndex   = c.fIndex;
   return *this;
}

//______________________________________________________________________________
Color_t TGLColor::GetColorIndex() const
{
   // Returns color-index representing the color.

   if (fIndex == -1)
      fIndex = TColor::GetColor(fRGBA[0], fRGBA[1], fRGBA[2]);
   return fIndex;
}

//______________________________________________________________________________
Char_t TGLColor::GetTransparency() const
{
   // Returns transparecy value.

   return TMath::Nint(100.0*(1.0 - fRGBA[3]/255.0));
}

//______________________________________________________________________________
void TGLColor::SetColor(Int_t r, Int_t g, Int_t b, Int_t a)
{
   // Set color with Int_t values.

   fRGBA[0] = r;
   fRGBA[1] = g;
   fRGBA[2] = b;
   fRGBA[3] = a;
   fIndex   = -1;
}

//______________________________________________________________________________
void TGLColor::SetColor(Float_t r, Float_t g, Float_t b, Float_t a)
{
   // Set color with Float_t values.

   fRGBA[0] = (UChar_t)(255*r);
   fRGBA[1] = (UChar_t)(255*g);
   fRGBA[2] = (UChar_t)(255*b);
   fRGBA[3] = (UChar_t)(255*a);
   fIndex   = -1;
}

//______________________________________________________________________________
void TGLColor::SetColor(Color_t color_index)
{
   // Set color by color-index. Alpha is not changed.
   // If color_index is not valid, color is set to magenta.

   TColor* c = gROOT->GetColor(color_index);
   if (c)
   {
      fRGBA[0] = (UChar_t)(255*c->GetRed());
      fRGBA[1] = (UChar_t)(255*c->GetGreen());
      fRGBA[2] = (UChar_t)(255*c->GetBlue());
      fIndex   = color_index;
   }
   else
   {
      // Set to magenta.
      fRGBA[0] = 255;
      fRGBA[1] = 0;
      fRGBA[2] = 255;
      fIndex   = -1;
   }
}

//______________________________________________________________________________
void TGLColor::SetColor(Color_t color_index, Char_t transparency)
{
   // Set color by color-index and alpha from the transparency.
   // If color_index is not valid, color is set to magenta.

   UChar_t alpha = (255*(100 - transparency))/100;

   TColor* c = gROOT->GetColor(color_index);
   if (c)
   {
      fRGBA[0] = (UChar_t)(255*c->GetRed());
      fRGBA[1] = (UChar_t)(255*c->GetGreen());
      fRGBA[2] = (UChar_t)(255*c->GetBlue());
      fRGBA[3] = alpha;
      fIndex   = color_index;
   }
   else
   {
      // Set to magenta.
      fRGBA[0] = 255;
      fRGBA[1] = 0;
      fRGBA[2] = 255;
      fRGBA[3] = alpha;
      fIndex   = -1;
      return;
   }
}

//______________________________________________________________________________
void TGLColor::SetTransparency(Char_t transparency)
{
   // Set alpha from the transparency.

   fRGBA[3] = (255*(100 - transparency))/100;
}

//______________________________________________________________________________
TString TGLColor::AsString() const
{
   // Return string describing the color.

   return TString::Format("rgba:%02hhx/%02hhx/%02hhx/%02hhx",
                          fRGBA[0], fRGBA[1], fRGBA[2], fRGBA[3]);
}


//==============================================================================
// TGLColorSet
//==============================================================================

//______________________________________________________________________________
//
// Class encapsulating a set of colors used throughout standard rendering.
//

ClassImp(TGLColorSet);

//______________________________________________________________________________
TGLColorSet::TGLColorSet()
{
   // Constructor. Sets default for dark background.

   StdDarkBackground();
}

//______________________________________________________________________________
TGLColorSet::~TGLColorSet()
{
   // Destructor.
}

//______________________________________________________________________________
TGLColorSet& TGLColorSet::operator=(const TGLColorSet& s)
{
   // Assignment operator.

   fBackground = s.fBackground;
   fForeground = s.fForeground;
   fOutline    = s.fOutline;
   fMarkup     = s.fMarkup;
   for (Int_t i = 0; i < 5; ++i)
      fSelection[i] = s.fSelection[i];
   return *this;
}

//______________________________________________________________________________
void TGLColorSet::StdDarkBackground()
{
   // Set defaults for dark (black) background.

   fBackground .SetColor(0,   0,   0);
   fForeground .SetColor(255, 255, 255);
   fOutline    .SetColor(240, 255, 240);
   fMarkup     .SetColor(200, 200, 200);

   fSelection[0].SetColor(  0,   0,   0);
   fSelection[1].SetColor(255, 220, 220);
   fSelection[2].SetColor(255, 220, 220);
   fSelection[3].SetColor(200, 200, 255);
   fSelection[4].SetColor(200, 200, 255);
}

//______________________________________________________________________________
void TGLColorSet::StdLightBackground()
{
   // Set defaults for light (white) background.

   fBackground .SetColor(255, 255, 255);
   fForeground .SetColor(0,   0,   0);
   fOutline    .SetColor(0,   0,   0);
   fMarkup     .SetColor(55,  55,  55);

   fSelection[0].SetColor(0,   0,   0);
   fSelection[1].SetColor(200, 100, 100);
   fSelection[2].SetColor(200, 100, 100);
   fSelection[3].SetColor(100, 100, 200);
   fSelection[4].SetColor(100, 100, 200);
}


//==============================================================================
// TGLUtil
//==============================================================================

//______________________________________________________________________________
//
// Wrapper class for various misc static functions - error checking,
// draw helpers etc.
//

ClassImp(TGLUtil);

UInt_t TGLUtil::fgDefaultDrawQuality = 10;
UInt_t TGLUtil::fgDrawQuality        = fgDefaultDrawQuality;
UInt_t TGLUtil::fgColorLockCount     = 0;

Float_t TGLUtil::fgPointSize      = 1.0f;
Float_t TGLUtil::fgLineWidth      = 1.0f;
Float_t TGLUtil::fgPointSizeScale = 1.0f;
Float_t TGLUtil::fgLineWidthScale = 1.0f;

Float_t TGLUtil::fgScreenScalingFactor     = 1.0f;
Float_t TGLUtil::fgPointLineScalingFactor  = 1.0f;
Int_t   TGLUtil::fgPickingRadius           = 1;

const UChar_t TGLUtil::fgRed[4]    = { 230,   0,   0, 255 };
const UChar_t TGLUtil::fgGreen[4]  = {   0, 230,   0, 255 };
const UChar_t TGLUtil::fgBlue[4]   = {   0,   0, 230, 255 };
const UChar_t TGLUtil::fgYellow[4] = { 210, 210,   0, 255 };
const UChar_t TGLUtil::fgWhite[4]  = { 255, 255, 255, 255 };
const UChar_t TGLUtil::fgGrey[4]   = { 128, 128, 128, 100 };

#ifndef CALLBACK
#define CALLBACK
#endif

extern "C"
{
#if defined(__APPLE_CC__) && __APPLE_CC__ > 4000 && __APPLE_CC__ < 5450 && !defined(__INTEL_COMPILER)
    typedef GLvoid (*tessfuncptr_t)(...);
#elif defined(__linux__) || defined(__FreeBSD__) || defined( __OpenBSD__ ) || defined(__sun) || defined (__CYGWIN__) || defined (__APPLE__)
    typedef GLvoid (*tessfuncptr_t)();
#elif defined (WIN32)
    typedef GLvoid (CALLBACK *tessfuncptr_t)();
#else
    #error "Error - need to define type tessfuncptr_t for this platform/compiler"
#endif
}

namespace
{

class TGLTesselatorWrap
{
protected:

public:
   GLUtesselator *fTess;

   TGLTesselatorWrap(tessfuncptr_t vertex_func) : fTess(0)
   {
      fTess = gluNewTess();
      if (!fTess)
         throw std::bad_alloc();

      gluTessCallback(fTess, (GLenum)GLU_BEGIN,  (tessfuncptr_t) glBegin);
      gluTessCallback(fTess, (GLenum)GLU_END,    (tessfuncptr_t) glEnd);
      gluTessCallback(fTess, (GLenum)GLU_VERTEX, vertex_func);
   }

   virtual ~TGLTesselatorWrap()
   {
      if (fTess)
         gluDeleteTess(fTess);
   }
};

}

//______________________________________________________________________________
GLUtesselator* TGLUtil::GetDrawTesselator3fv()
{
   // Returns a tesselator for direct drawing when using 3-vertices with
   // single precision.

   static TGLTesselatorWrap singleton((tessfuncptr_t) glVertex3fv);

   return singleton.fTess;
}

//______________________________________________________________________________
GLUtesselator* TGLUtil::GetDrawTesselator4fv()
{
   // Returns a tesselator for direct drawing when using 4-vertices with
   // single precision.

   static TGLTesselatorWrap singleton((tessfuncptr_t) glVertex4fv);

   return singleton.fTess;
}

//______________________________________________________________________________
GLUtesselator* TGLUtil::GetDrawTesselator3dv()
{
   // Returns a tesselator for direct drawing when using 3-vertices with
   // double precision.

   static TGLTesselatorWrap singleton((tessfuncptr_t) glVertex3dv);

   return singleton.fTess;
}

//______________________________________________________________________________
GLUtesselator* TGLUtil::GetDrawTesselator4dv()
{
   // Returns a tesselator for direct drawing when using 4-vertices with
   // double precision.

   static TGLTesselatorWrap singleton((tessfuncptr_t) glVertex4dv);

   return singleton.fTess;
}

//______________________________________________________________________________
void TGLUtil::InitializeIfNeeded()
{
   // Initialize globals that require other libraries to be initialized.
   // This is called from TGLWidget creation function.

   static Bool_t init_done = kFALSE;
   if (init_done) return;
   init_done = kTRUE;

   fgScreenScalingFactor = gVirtualX->GetOpenGLScalingFactor();

   if (strcmp(gEnv->GetValue("OpenGL.PointLineScalingFactor", "native"), "native") == 0)
   {
      fgPointLineScalingFactor = fgScreenScalingFactor;
   }
   else
   {
      fgPointLineScalingFactor = gEnv->GetValue("OpenGL.PointLineScalingFactor", 1.0);
   }

   fgPickingRadius = TMath::Nint(gEnv->GetValue("OpenGL.PickingRadius", 3.0) * TMath::Sqrt(fgScreenScalingFactor));
}

//______________________________________________________________________________
UInt_t TGLUtil::GetDrawQuality()
{
   //static: get draw quality
   return fgDrawQuality;
}

//______________________________________________________________________________
void TGLUtil::SetDrawQuality(UInt_t dq)
{
   //static: set draw quality
   fgDrawQuality = dq;
}

//______________________________________________________________________________
void TGLUtil::ResetDrawQuality()
{
   //static: reset draw quality
   fgDrawQuality = fgDefaultDrawQuality;
}

//______________________________________________________________________________
UInt_t TGLUtil::GetDefaultDrawQuality()
{
   //static: get default draw quality
   return fgDefaultDrawQuality;
}

//______________________________________________________________________________
void TGLUtil::SetDefaultDrawQuality(UInt_t dq)
{
   //static: set default draw quality
   fgDefaultDrawQuality = dq;
}

//______________________________________________________________________________
Int_t TGLUtil::CheckError(const char * loc)
{
   // Check current GL error state, outputing details via ROOT
   // Error method if one
   GLenum errCode;
   const GLubyte *errString;

   if ((errCode = glGetError()) != GL_NO_ERROR) {
      errString = gluErrorString(errCode);
      if (loc) {
         Error(loc, "GL Error %s", (const char *)errString);
      } else {
         Error("TGLUtil::CheckError", "GL Error %s", (const char *)errString);
      }
   }
   return errCode;
}

/******************************************************************************/
// Color wrapping functions
/******************************************************************************/

//______________________________________________________________________________
UInt_t TGLUtil::LockColor()
{
   // Prevent further color changes.

   return ++fgColorLockCount;
}

//______________________________________________________________________________
UInt_t TGLUtil::UnlockColor()
{
   // Allow color changes.

   if (fgColorLockCount)
      --fgColorLockCount;
   else
      Error("TGLUtil::UnlockColor", "fgColorLockCount already 0.");
   return fgColorLockCount;
}

//______________________________________________________________________________
Bool_t TGLUtil::IsColorLocked()
{
   // Returns true if color lockcount is greater than 0.

   return fgColorLockCount > 0;
}

//______________________________________________________________________________
void TGLUtil::Color(const TGLColor& color)
{
   // Set color from TGLColor.

   if (fgColorLockCount == 0) glColor4ubv(color.CArr());
}

//______________________________________________________________________________
void TGLUtil::ColorAlpha(const TGLColor& color, UChar_t alpha)
{
   // Set color from TGLColor and alpha value.

   if (fgColorLockCount == 0)
   {
      glColor4ub(color.GetRed(), color.GetGreen(), color.GetBlue(), alpha);
   }
}

//______________________________________________________________________________
void TGLUtil::ColorAlpha(const TGLColor& color, Float_t alpha)
{
   // Set color from TGLColor and alpha value.

   if (fgColorLockCount == 0)
   {
      glColor4ub(color.GetRed(), color.GetGreen(), color.GetBlue(), (UChar_t)(255*alpha));
   }
}

//______________________________________________________________________________
void TGLUtil::ColorAlpha(Color_t color_index, Float_t alpha)
{
   // Set color from color_index and GL-style alpha (default 1).

   if (fgColorLockCount == 0) {
      if (color_index < 0)
         color_index = 1;
      TColor* c = gROOT->GetColor(color_index);
      if (c)
         glColor4f(c->GetRed(), c->GetGreen(), c->GetBlue(), alpha);
   }
}

//______________________________________________________________________________
void TGLUtil::ColorTransparency(Color_t color_index, Char_t transparency)
{
   // Set color from color_index and ROOT-style transparency (default 0).

   if (fgColorLockCount == 0) {
      if (color_index < 0)
         color_index = 1;
      TColor* c = gROOT->GetColor(color_index);
      if (c)
         glColor4f(c->GetRed(), c->GetGreen(), c->GetBlue(), 1.0f - 0.01f*transparency);
   }
}

//______________________________________________________________________________
void TGLUtil::Color3ub(UChar_t r, UChar_t g, UChar_t b)
{
   // Wrapper for glColor3ub.
   if (fgColorLockCount == 0) glColor3ub(r, g, b);
}

//______________________________________________________________________________
void TGLUtil::Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a)
{
   // Wrapper for glColor4ub.
   if (fgColorLockCount == 0) glColor4ub(r, g, b, a);
}

//______________________________________________________________________________
void TGLUtil::Color3ubv(const UChar_t* rgb)
{
   // Wrapper for glColor3ubv.
   if (fgColorLockCount == 0) glColor3ubv(rgb);
}

//______________________________________________________________________________
void TGLUtil::Color4ubv(const UChar_t* rgba)
{
   // Wrapper for glColor4ubv.
   if (fgColorLockCount == 0) glColor4ubv(rgba);
}

//______________________________________________________________________________
void TGLUtil::Color3f(Float_t r, Float_t g, Float_t b)
{
   // Wrapper for glColor3f.
   if (fgColorLockCount == 0) glColor3f(r, g, b);
}

//______________________________________________________________________________
void TGLUtil::Color4f(Float_t r, Float_t g, Float_t b, Float_t a)
{
   // Wrapper for glColor4f.
   if (fgColorLockCount == 0) glColor4f(r, g, b, a);
}

//______________________________________________________________________________
void TGLUtil::Color3fv(const Float_t* rgb)
{
   // Wrapper for glColor3fv.
   if (fgColorLockCount == 0) glColor3fv(rgb);
}

//______________________________________________________________________________
void TGLUtil::Color4fv(const Float_t* rgba)
{
   // Wrapper for glColor4fv.
   if (fgColorLockCount == 0) glColor4fv(rgba);
}

/******************************************************************************/
// Coordinate conversion and extra scaling (needed for osx retina)
/******************************************************************************/

//______________________________________________________________________________
void TGLUtil::PointToViewport(Int_t& x, Int_t& y)
{
   // Convert from point/screen coordinates to GL viewport coordinates.

   if (fgScreenScalingFactor != 1.0)
   {
      x = TMath::Nint(x * fgScreenScalingFactor);
      y = TMath::Nint(y * fgScreenScalingFactor);
   }
}

//______________________________________________________________________________
void TGLUtil::PointToViewport(Int_t& x, Int_t& y, Int_t& w, Int_t& h)
{
   // Convert from point/screen coordinates to GL viewport coordinates.

   if (fgScreenScalingFactor != 1.0)
   {
      x = TMath::Nint(x * fgScreenScalingFactor);
      y = TMath::Nint(y * fgScreenScalingFactor);
      w = TMath::Nint(w * fgScreenScalingFactor);
      h = TMath::Nint(h * fgScreenScalingFactor);
   }
}

//______________________________________________________________________________
Float_t TGLUtil::GetScreenScalingFactor()
{
   // Returns scaling factor between screen points and GL viewport pixels.
   // This is what is returned by gVirtualX->GetOpenGLScalingFactor() but is
   // cached here to avoid a virtual function call as it is used quite often in
   // TGLPhysical shape when drawing the selection highlight.

   return fgScreenScalingFactor;
}

//______________________________________________________________________________
Float_t TGLUtil::GetPointLineScalingFactor()
{
   // Return extra scaling factor for points and lines.
   // By default this is set to the same value as ScreenScalingFactor to keep
   // the same appearance. To override use rootrc entry, e.g.:
   // OpenGL.PointLineScalingFactor: 1.0

   return fgPointLineScalingFactor;
}

//______________________________________________________________________________
Int_t TGLUtil::GetPickingRadius()
{
   // Returns picking radius.

   return fgPickingRadius;
}

/******************************************************************************/
// Control for scaling of point-size and line-width.
/******************************************************************************/

//______________________________________________________________________________
Float_t TGLUtil::GetPointSizeScale()
{
   // Get global point-size scale.

   return fgPointSizeScale;
}

//______________________________________________________________________________
void TGLUtil::SetPointSizeScale(Float_t scale)
{
   // Set global point-size scale.

   fgPointSizeScale = scale;
}

//______________________________________________________________________________
Float_t TGLUtil::GetLineWidthScale()
{
   // Returns global line-width scale.

   return fgLineWidthScale;
}

//______________________________________________________________________________
void TGLUtil::SetLineWidthScale(Float_t scale)
{
   // Set global line-width scale.

   fgLineWidthScale = scale;
}

//______________________________________________________________________________
void TGLUtil::PointSize(Float_t point_size)
{
   // Set the point-size, taking the global scaling into account.
   // Wrapper for glPointSize.

   fgPointSize = point_size * fgPointSizeScale * fgPointLineScalingFactor;
   glPointSize(fgPointSize);
}

//______________________________________________________________________________
void TGLUtil::LineWidth(Float_t line_width)
{
   // Set the line-width, taking the global scaling into account.
   // Wrapper for glLineWidth.

   fgLineWidth = line_width * fgLineWidthScale * fgPointLineScalingFactor;
   glLineWidth(fgLineWidth);
}

//______________________________________________________________________________
Float_t TGLUtil::PointSize()
{
   // Get the point-size, taking the global scaling into account.

   return fgPointSize;
}

//______________________________________________________________________________
Float_t TGLUtil::LineWidth()
{
   // Get the line-width, taking the global scaling into account.

   return fgLineWidth;
}

/******************************************************************************/
// Rendering of polymarkers and lines from logical-shapes.
/******************************************************************************/

void TGLUtil::BeginExtendPickRegion(Float_t scale)
{
   // Extend pick region for large point-sizes or line-widths.

   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   Float_t pm[16];
   glGetFloatv(GL_PROJECTION_MATRIX, pm);
   for (Int_t i=0; i<=12; i+=4) {
      pm[i] *= scale; pm[i+1] *= scale;
   }
   glLoadMatrixf(pm);
   glMatrixMode(GL_MODELVIEW);
}

void TGLUtil::EndExtendPickRegion()
{
   // End extension of the pick region.

   glMatrixMode(GL_PROJECTION);
   glPopMatrix();
   glMatrixMode(GL_MODELVIEW);
}

//______________________________________________________________________________
void TGLUtil::RenderPolyMarkers(const TAttMarker& marker, Char_t transp,
                                Float_t* p, Int_t n,
                                Int_t pick_radius, Bool_t selection,
                                Bool_t sec_selection)
{
   // Render polymarkers at points specified by p-array.
   // Supports point and cross-like styles.

   if (n == 0) return;

   glPushAttrib(GL_ENABLE_BIT | GL_POINT_BIT | GL_LINE_BIT);

   glDisable(GL_LIGHTING);
   TGLUtil::ColorTransparency(marker.GetMarkerColor(), transp);

   Int_t s = marker.GetMarkerStyle();
   if (s == 2 || s == 3 || s == 5 || s == 28)
      RenderCrosses(marker, p, n, sec_selection);
   else
      RenderPoints(marker, p, n, pick_radius, selection, sec_selection);

   glPopAttrib();
}

//______________________________________________________________________________
void TGLUtil::RenderPolyMarkers(const TAttMarker &marker, const std::vector<Double_t> &points,
                                Double_t dX, Double_t dY, Double_t dZ)
{
   // Render polymarkers at points specified by p-array.
   // Supports point and cross-like styles.
   // Color is set externally. Lighting is disabled externally.

   const Int_t s = marker.GetMarkerStyle();
   if (s == 2 || s == 3 || s == 5 || s == 28)
      RenderCrosses(marker, points, dX, dY, dZ);
   else
      RenderPoints(marker, points);
}

//______________________________________________________________________________
void TGLUtil::RenderPoints(const TAttMarker& marker,
                           Float_t* op, Int_t n,
                           Int_t pick_radius, Bool_t selection,
                           Bool_t sec_selection)
{
   // Render markers as circular or square points.
   // Color is never changed.

   Int_t   style = marker.GetMarkerStyle();
   Float_t size  = 5*marker.GetMarkerSize();
   if (style == 4 || style == 20 || style == 24)
   {
      glEnable(GL_POINT_SMOOTH);
      if (style == 4 || style == 24) {
         glEnable(GL_BLEND);
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
      }
   }
   else
   {
      glDisable(GL_POINT_SMOOTH);
      if      (style == 1) size = 1;
      else if (style == 6) size = 2;
      else if (style == 7) size = 3;
   }
   TGLUtil::PointSize(size);

   // During selection extend picking region for large point-sizes.
   Bool_t changePM = selection && PointSize() > pick_radius;
   if (changePM)
      BeginExtendPickRegion((Float_t) pick_radius / PointSize());

   Float_t* p = op;
   if (sec_selection)
   {
      glPushName(0);
      for (Int_t i=0; i<n; ++i, p+=3)
      {
         glLoadName(i);
         glBegin(GL_POINTS);
         glVertex3fv(p);
         glEnd();
      }
      glPopName();
   }
   else
   {
      glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
      glVertexPointer(3, GL_FLOAT, 0, p);
      glEnableClientState(GL_VERTEX_ARRAY);
      { // Circumvent bug in ATI's linux drivers.
         Int_t nleft = n;
         Int_t ndone = 0;
         const Int_t maxChunk = 8192;
         while (nleft > maxChunk)
         {
            glDrawArrays(GL_POINTS, ndone, maxChunk);
            nleft -= maxChunk;
            ndone += maxChunk;
         }
         glDrawArrays(GL_POINTS, ndone, nleft);
      }
      glPopClientAttrib();
   }

   if (changePM)
      EndExtendPickRegion();
}

//______________________________________________________________________________
void TGLUtil::RenderPoints(const TAttMarker& marker, const std::vector<Double_t> &points)
{
   // Render markers as circular or square points.
   // Color is never changed.
   const Int_t style = marker.GetMarkerStyle();
   Float_t size = 5 * marker.GetMarkerSize();

   if (style == 4 || style == 20 || style == 24)
   {
      glEnable(GL_POINT_SMOOTH);
      if (style == 4 || style == 24) {
         glEnable(GL_BLEND);
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
      }
   }
   else
   {
      glDisable(GL_POINT_SMOOTH);
      if      (style == 1) size = 1;
      else if (style == 6) size = 2;
      else if (style == 7) size = 3;
   }

   glPointSize(size);

   glVertexPointer(3, GL_DOUBLE, 0, &points[0]);
   glEnableClientState(GL_VERTEX_ARRAY);

   // Circumvent bug in ATI's linux drivers.
   Int_t nleft = points.size() / 3;
   Int_t ndone = 0;
   const Int_t maxChunk = 8192;
   while (nleft > maxChunk)
   {
      glDrawArrays(GL_POINTS, ndone, maxChunk);
      nleft -= maxChunk;
      ndone += maxChunk;
   }

   if (nleft > 0)
      glDrawArrays(GL_POINTS, ndone, nleft);

   glDisableClientState(GL_VERTEX_ARRAY);
   glPointSize(1.f);
}

//______________________________________________________________________________
void TGLUtil::RenderCrosses(const TAttMarker& marker,
                            Float_t* op, Int_t n,
                            Bool_t sec_selection)
{
   // Render markers as crosses.
   // Color is never changed.

   if (marker.GetMarkerStyle() == 28)
   {
      glEnable(GL_BLEND);
      glEnable(GL_LINE_SMOOTH);
      TGLUtil::LineWidth(2);
   }
   else
   {
      glDisable(GL_LINE_SMOOTH);
      TGLUtil::LineWidth(1);
   }

   // cross dim
   const Float_t d = 2*marker.GetMarkerSize();
   Float_t* p = op;
   if (sec_selection)
   {
      glPushName(0);
      for (Int_t i=0; i<n; ++i, p+=3)
      {
         glLoadName(i);
         glBegin(GL_LINES);
         glVertex3f(p[0]-d, p[1],   p[2]);   glVertex3f(p[0]+d, p[1],   p[2]);
         glVertex3f(p[0],   p[1]-d, p[2]);   glVertex3f(p[0],   p[1]+d, p[2]);
         glVertex3f(p[0],   p[1],   p[2]-d); glVertex3f(p[0],   p[1],   p[2]+d);
         glEnd();
      }
      glPopName();
   }
   else
   {
      glBegin(GL_LINES);
      for (Int_t i=0; i<n; ++i, p+=3)
      {
         glVertex3f(p[0]-d, p[1],   p[2]);   glVertex3f(p[0]+d, p[1],   p[2]);
         glVertex3f(p[0],   p[1]-d, p[2]);   glVertex3f(p[0],   p[1]+d, p[2]);
         glVertex3f(p[0],   p[1],   p[2]-d); glVertex3f(p[0],   p[1],   p[2]+d);
      }
      glEnd();
   }

   // Anti-flickering -- when crosses get too small they
   // appear / disappear randomly.
   {
      glDisable(GL_POINT_SMOOTH);
      TGLUtil::PointSize(1);

      glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
      glVertexPointer(3, GL_FLOAT, 0, op);
      glEnableClientState(GL_VERTEX_ARRAY);
      { // Circumvent bug in ATI's linux drivers.
         Int_t nleft = n;
         Int_t ndone = 0;
         const Int_t maxChunk = 8192;
         while (nleft > maxChunk)
         {
            glDrawArrays(GL_POINTS, ndone, maxChunk);
            nleft -= maxChunk;
            ndone += maxChunk;
         }
         glDrawArrays(GL_POINTS, ndone, nleft);
      }
      glPopClientAttrib();
   }
}

//______________________________________________________________________________
void TGLUtil::RenderCrosses(const TAttMarker& marker, const std::vector<Double_t> &points,
                            Double_t dX, Double_t dY, Double_t dZ)
{
   // Render markers as crosses.
   // Color is never changed.
   if (marker.GetMarkerStyle() == 28)
   {
      glEnable(GL_BLEND);
      glEnable(GL_LINE_SMOOTH);
      glLineWidth(2.f);
   }
   else
   {
      glDisable(GL_LINE_SMOOTH);
      glLineWidth(1.f);
   }

   typedef std::vector<Double_t>::size_type size_type;

   glBegin(GL_LINES);

   for (size_type i = 0; i < points.size(); i += 3) {
      const Double_t *p = &points[i];
      glVertex3f(p[0] - dX, p[1], p[2]); glVertex3f(p[0] + dX, p[1], p[2]);
      glVertex3f(p[0], p[1] - dY, p[2]); glVertex3f(p[0], p[1] + dY, p[2]);
      glVertex3f(p[0], p[1], p[2] - dZ); glVertex3f(p[0], p[1], p[2] + dZ);
   }

   glEnd();

   if (marker.GetMarkerStyle() == 28) {
      glDisable(GL_LINE_SMOOTH);
      glDisable(GL_BLEND);
      glLineWidth(1.f);
   }
}

//______________________________________________________________________________
void TGLUtil::RenderPolyLine(const TAttLine& aline, Char_t transp,
                             Float_t* p, Int_t n,
                             Int_t pick_radius, Bool_t selection)
{
   // Render poly-line as specified by the p-array.

   if (n == 0) return;

   BeginAttLine(aline, transp, pick_radius, selection);

   Float_t* tp = p;
   glBegin(GL_LINE_STRIP);
   for (Int_t i=0; i<n; ++i, tp+=3)
      glVertex3fv(tp);
   glEnd();

   EndAttLine(pick_radius, selection);
}

//______________________________________________________________________________
void TGLUtil::BeginAttLine(const TAttLine& aline, Char_t transp,
                           Int_t pick_radius, Bool_t selection)
{
   // Setup drawing parrameters according to passed TAttLine.

   glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);

   glDisable(GL_LIGHTING);
   TGLUtil::ColorTransparency(aline.GetLineColor(), transp);
   TGLUtil::LineWidth(aline.GetLineWidth());
   if (aline.GetLineStyle() > 1)
   {
      // Int_t    fac = 1;
      UShort_t pat = 0xffff;
      switch (aline.GetLineStyle()) {
         case 2:  pat = 0x3333; break;
         case 3:  pat = 0x5555; break;
         case 4:  pat = 0xf040; break;
         case 5:  pat = 0xf4f4; break;
         case 6:  pat = 0xf111; break;
         case 7:  pat = 0xf0f0; break;
         case 8:  pat = 0xff11; break;
         case 9:  pat = 0x3fff; break;
         case 10: pat = 0x08ff; /* fac = 2; */ break;
      }

      glLineStipple(1, pat);
      glEnable(GL_LINE_STIPPLE);
   }

   // During selection extend picking region for large line-widths.
   if (selection && TGLUtil::LineWidth() > pick_radius)
      BeginExtendPickRegion((Float_t) pick_radius / TGLUtil::LineWidth());
}

//______________________________________________________________________________
void TGLUtil::EndAttLine(Int_t pick_radius, Bool_t selection)
{
   // Restore previous line drawing state.

   if (selection && TGLUtil::LineWidth() > pick_radius)
     EndExtendPickRegion();

   glPopAttrib();
}

/******************************************************************************/
// Rendering atoms used by TGLViewer / TGScene.
/******************************************************************************/

//______________________________________________________________________________
void TGLUtil::SetDrawColors(const UChar_t rgbai[4])
{
   // Set basic draw colors from 4 component 'rgba'
   // Used by other TGLUtil drawing routines
   //
   // Sets basic (unlit) color - glColor
   // and also GL materials (see OpenGL docs) thus:
   //
   // diffuse  : rgba
   // ambient  : 0.0 0.0 0.0 1.0
   // specular : 0.6 0.6 0.6 1.0
   // emission : rgba/4.0
   // shininess: 60.0
   //
   // emission is set so objects with no lights (but lighting still enabled)
   // are partially visible


   // Util function to setup GL color for both unlit and lit material
   Float_t rgba[4]     = {rgbai[0]/255.f, rgbai[1]/255.f, rgbai[2]/255.f, rgbai[3]/255.f};
   Float_t ambient[4]  = {0.0, 0.0, 0.0, 1.0};
   Float_t specular[4] = {0.6, 0.6, 0.6, 1.0};
   Float_t emission[4] = {rgba[0]/4.f, rgba[1]/4.f, rgba[2]/4.f, rgba[3]};

   glColor4fv(rgba);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, rgba);
   glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
   glMaterialfv(GL_FRONT, GL_SPECULAR, specular);
   glMaterialfv(GL_FRONT, GL_EMISSION, emission);
   glMaterialf(GL_FRONT, GL_SHININESS, 60.0);
}

//______________________________________________________________________________
void TGLUtil::DrawSphere(const TGLVertex3 & position, Double_t radius,
                         const UChar_t rgba[4])
{
   // Draw sphere, centered on vertex 'position', with radius 'radius',
   // color 'rgba'
   static TGLQuadric quad;
   SetDrawColors(rgba);
   glPushMatrix();
   glTranslated(position.X(), position.Y(), position.Z());
   gluSphere(quad.Get(), radius, fgDrawQuality, fgDrawQuality);
   glPopMatrix();
}

//______________________________________________________________________________
void TGLUtil::DrawLine(const TGLLine3 & line, ELineHeadShape head, Double_t size,
                       const UChar_t rgba[4])
{
   // Draw thick line (tube) defined by 'line', with head at end shape
   // 'head' - box/arrow/none, (head) size 'size', color 'rgba'
   DrawLine(line.Start(), line.Vector(), head, size, rgba);
}

//______________________________________________________________________________
void TGLUtil::DrawLine(const TGLVertex3 & start, const TGLVector3 & vector,
                       ELineHeadShape head, Double_t size, const UChar_t rgba[4])
{
   // Draw thick line (tube) running from 'start', length 'vector',
   // with head at end of shape 'head' - box/arrow/none,
   // (head) size 'size', color 'rgba'
   static TGLQuadric quad;

   // Draw 3D line (tube) with optional head shape
   SetDrawColors(rgba);
   glPushMatrix();
   TGLMatrix local(start, vector);
   glMultMatrixd(local.CArr());

   Double_t headHeight=0;
   if (head == kLineHeadNone) {
      headHeight = 0.0;
   } else if (head == kLineHeadArrow) {
      headHeight = size*2.0;
   } else if (head == kLineHeadBox) {
      headHeight = size*1.4;
   }

   // Line (tube) component
   gluCylinder(quad.Get(), 0.25*size, 0.25*size, vector.Mag() - headHeight, fgDrawQuality, 1);
   gluQuadricOrientation(quad.Get(), (GLenum)GLU_INSIDE);
   gluDisk(quad.Get(), 0.0, 0.25*size, fgDrawQuality, 1);

   glTranslated(0.0, 0.0, vector.Mag() - headHeight); // Shift down local Z to end of line

   if (head == kLineHeadNone) {
      // Cap end of line
      gluQuadricOrientation(quad.Get(), (GLenum)GLU_OUTSIDE);
      gluDisk(quad.Get(), 0.0, size/4.0, fgDrawQuality, 1);
   }
   else if (head == kLineHeadArrow) {
      // Arrow base / end line cap
      gluDisk(quad.Get(), 0.0, size, fgDrawQuality, 1);
      // Arrow cone
      gluQuadricOrientation(quad.Get(), (GLenum)GLU_OUTSIDE);
      gluCylinder(quad.Get(), size, 0.0, headHeight, fgDrawQuality, 1);
   } else if (head == kLineHeadBox) {
      // Box
      // TODO: Drawing box should be simplier - maybe make
      // a static helper which BB + others use.
      // Single face tesselation - ugly lighting
      gluQuadricOrientation(quad.Get(), (GLenum)GLU_OUTSIDE);
      TGLBoundingBox box(TGLVertex3(-size*.7, -size*.7, 0.0),
                         TGLVertex3(size*.7, size*.7, headHeight));
      box.Draw(kTRUE);
   }
   glPopMatrix();
}

//______________________________________________________________________________
void TGLUtil::DrawRing(const TGLVertex3 & center, const TGLVector3 & normal,
                       Double_t radius, const UChar_t rgba[4])
{
   // Draw ring, centered on 'center', lying on plane defined by 'center' & 'normal'
   // of outer radius 'radius', color 'rgba'
   static TGLQuadric quad;

   // Draw a ring, round vertex 'center', lying on plane defined by 'normal' vector
   // Radius defines the outer radius
   TGLUtil::SetDrawColors(rgba);

   Double_t outer = radius;
   Double_t width = radius*0.05;
   Double_t inner = outer - width;

   // Shift into local system, looking down 'normal' vector, origin at center
   glPushMatrix();
   TGLMatrix local(center, normal);
   glMultMatrixd(local.CArr());

   // Shift half width so rings centered over center vertex
   glTranslated(0.0, 0.0, -width/2.0);

   // Inner and outer faces
   gluCylinder(quad.Get(), inner, inner, width, fgDrawQuality, 1);
   gluCylinder(quad.Get(), outer, outer, width, fgDrawQuality, 1);

   // Top/bottom
   gluQuadricOrientation(quad.Get(), (GLenum)GLU_INSIDE);
   gluDisk(quad.Get(), inner, outer, fgDrawQuality, 1);
   glTranslated(0.0, 0.0, width);
   gluQuadricOrientation(quad.Get(), (GLenum)GLU_OUTSIDE);
   gluDisk(quad.Get(), inner, outer, fgDrawQuality, 1);

   glPopMatrix();
}

/**************************************************************************/

//______________________________________________________________________________
void TGLUtil::DrawReferenceMarker(const TGLCamera  & camera,
                                  const TGLVertex3 & pos,
                                        Float_t      radius,
                                  const UChar_t    * rgba)
{
   // Draw a sphere- marker on world-coordinate 'pos' with pixel
   // radius 'radius'. Color argument is optional.

   static const UChar_t defColor[4] = { 250, 110, 0, 255 }; // Orange

   radius = camera.ViewportDeltaToWorld(pos, radius, radius).Mag();
   DrawSphere(pos, radius, rgba ? rgba : defColor);

}

//______________________________________________________________________________
void TGLUtil::DrawSimpleAxes(const TGLCamera      & camera,
                             const TGLBoundingBox & bbox,
                                   Int_t            axesType)
{
   // Draw simple xyz-axes for given bounding-box.

   if (axesType == kAxesNone)
      return;

   static const UChar_t axesColors[][4] = {
      {128,   0,   0, 255},  // -ive X axis light red
      {255,   0,   0, 255},  // +ive X axis deep red
      {  0, 128,   0, 255},  // -ive Y axis light green
      {  0, 255,   0, 255},  // +ive Y axis deep green
      {  0,   0, 128, 255},  // -ive Z axis light blue
      {  0,   0, 255, 255}   // +ive Z axis deep blue
   };

   static const UChar_t xyz[][8] = {
      {0x44, 0x44, 0x28, 0x10, 0x10, 0x28, 0x44, 0x44},
      {0x10, 0x10, 0x10, 0x10, 0x10, 0x28, 0x44, 0x44},
      {0x7c, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x7c}
   };

   // Axes draw at fixed screen size - back project to world
   TGLVector3 pixelVector = camera.ViewportDeltaToWorld(bbox.Center(), 1, 1);
   Double_t   pixelSize   = pixelVector.Mag();

   // Find x/y/z min/max values
   Double_t min[3] = { bbox.XMin(), bbox.YMin(), bbox.ZMin() };
   Double_t max[3] = { bbox.XMax(), bbox.YMax(), bbox.ZMax() };

   for (UInt_t i = 0; i < 3; i++) {
      TGLVertex3 start;
      TGLVector3 vector;

      if (axesType == kAxesOrigin) {
         // Through origin axes
         start[(i+1)%3] = 0.0;
         start[(i+2)%3] = 0.0;
      } else {
         // Side axes
         start[(i+1)%3] = min[(i+1)%3];
         start[(i+2)%3] = min[(i+2)%3];
      }
      vector[(i+1)%3] = 0.0;
      vector[(i+2)%3] = 0.0;

      // -ive axis?
      if (min[i] < 0.0) {
         // Runs from origin?
         if (max[i] > 0.0) {
            start[i] = 0.0;
            vector[i] = min[i];
         } else {
            start[i] = max[i];
            vector[i] = min[i] - max[i];
         }
         DrawLine(start, vector, kLineHeadNone, pixelSize*2.5, axesColors[i*2]);
      }
      // +ive axis?
      if (max[i] > 0.0) {
         // Runs from origin?
         if (min[i] < 0.0) {
            start[i] = 0.0;
            vector[i] = max[i];
         } else {
            start[i] = min[i];
            vector[i] = max[i] - min[i];
         }
         DrawLine(start, vector, kLineHeadNone, pixelSize*2.5, axesColors[i*2 + 1]);
      }
   }

   // Draw origin sphere(s)
   if (axesType == kAxesOrigin) {
      // Single white origin sphere at 0, 0, 0
      DrawSphere(TGLVertex3(0.0, 0.0, 0.0), pixelSize*2.0, fgWhite);
   } else {
      for (UInt_t j = 0; j < 3; j++) {
         if (min[j] <= 0.0 && max[j] >= 0.0) {
            TGLVertex3 zero;
            zero[j] = 0.0;
            zero[(j+1)%3] = min[(j+1)%3];
            zero[(j+2)%3] = min[(j+2)%3];
            DrawSphere(zero, pixelSize*2.0, axesColors[j*2 + 1]);
         }
      }
   }

   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

   // Labels
   Double_t padPixels = 25.0;

   glDisable(GL_LIGHTING);
   for (UInt_t k = 0; k < 3; k++) {
      SetDrawColors(axesColors[k*2+1]);
      TGLVertex3 minPos, maxPos;
      if (axesType == kAxesOrigin) {
         minPos[(k+1)%3] = 0.0;
         minPos[(k+2)%3] = 0.0;
      } else {
         minPos[(k+1)%3] = min[(k+1)%3];
         minPos[(k+2)%3] = min[(k+2)%3];
      }
      maxPos = minPos;
      minPos[k] = min[k];
      maxPos[k] = max[k];

      TGLVector3 axis = maxPos - minPos;
      TGLVector3 axisViewport = camera.WorldDeltaToViewport(minPos, axis);

      // Skip drawning if viewport projection of axis very small - labels will overlap
      // Occurs with orthographic cameras
      if (axisViewport.Mag() < 1) {
         continue;
      }

      minPos -= camera.ViewportDeltaToWorld(minPos, padPixels*axisViewport.X()/axisViewport.Mag(),
                                                    padPixels*axisViewport.Y()/axisViewport.Mag());
      axisViewport = camera.WorldDeltaToViewport(maxPos, -axis);
      maxPos -= camera.ViewportDeltaToWorld(maxPos, padPixels*axisViewport.X()/axisViewport.Mag(),
                                                    padPixels*axisViewport.Y()/axisViewport.Mag());

      DrawNumber(Form("%.0f", min[k]), minPos, kTRUE); // Min value
      DrawNumber(Form("%.0f", max[k]), maxPos, kTRUE); // Max value

      // Axis name beside max value
      TGLVertex3 namePos = maxPos -
         camera.ViewportDeltaToWorld(maxPos, padPixels*axisViewport.X()/axisViewport.Mag(),
                                     padPixels*axisViewport.Y()/axisViewport.Mag());
      glRasterPos3dv(namePos.CArr());
      glBitmap(8, 8, 0.0, 4.0, 0.0, 0.0, xyz[k]); // Axis Name
   }
}

//______________________________________________________________________________
void TGLUtil::DrawNumber(const TString    & num,
                         const TGLVertex3 & pos,
                               Bool_t       center)
{
   // Draw number in string 'num' via internal 8x8-pixel bitmap on
   // vertex 'pos'. If 'center' is true, the number is centered on 'pos'.
   // Only numbers, '.', '-' and ' ' are supported.

   static const UChar_t digits[][8] = {
      {0x38, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x38},//0
      {0x10, 0x10, 0x10, 0x10, 0x10, 0x70, 0x10, 0x10},//1
      {0x7c, 0x44, 0x20, 0x18, 0x04, 0x04, 0x44, 0x38},//2
      {0x38, 0x44, 0x04, 0x04, 0x18, 0x04, 0x44, 0x38},//3
      {0x04, 0x04, 0x04, 0x04, 0x7c, 0x44, 0x44, 0x44},//4
      {0x7c, 0x44, 0x04, 0x04, 0x7c, 0x40, 0x40, 0x7c},//5
      {0x7c, 0x44, 0x44, 0x44, 0x7c, 0x40, 0x40, 0x7c},//6
      {0x20, 0x20, 0x20, 0x10, 0x08, 0x04, 0x44, 0x7c},//7
      {0x38, 0x44, 0x44, 0x44, 0x38, 0x44, 0x44, 0x38},//8
      {0x7c, 0x44, 0x04, 0x04, 0x7c, 0x44, 0x44, 0x7c},//9
      {0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},//.
      {0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00},//-
      {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} //space
   };

   Double_t xOffset = 0, yOffset = 0;
   if (center)
   {
      xOffset = 3.5 * num.Length();
      yOffset = 4.0;
   }

   glRasterPos3dv(pos.CArr());
   for (Ssiz_t i = 0, e = num.Length(); i < e; ++i) {
      if (num[i] == '.') {
         glBitmap(8, 8, xOffset, yOffset, 7.0, 0.0, digits[10]);
      } else if (num[i] == '-') {
         glBitmap(8, 8, xOffset, yOffset, 7.0, 0.0, digits[11]);
      } else if (num[i] == ' ') {
         glBitmap(8, 8, xOffset, yOffset, 7.0, 0.0, digits[12]);
      } else if (num[i] >= '0' && num[i] <= '9') {
         glBitmap(8, 8, xOffset, yOffset, 7.0, 0.0, digits[num[i] - '0']);
      }
   }
}


/**************************************************************************/
/**************************************************************************/

//______________________________________________________________________________
TGLCapabilitySwitch::TGLCapabilitySwitch(Int_t what, Bool_t state) :
   fWhat(what)
{
   // Constructor - change state only if necessary.

   fState = glIsEnabled(fWhat);
   fFlip  = (fState != state);
   if (fFlip)
      SetState(state);
}

//______________________________________________________________________________
TGLCapabilitySwitch::~TGLCapabilitySwitch()
{
   // Destructor - reset state if changed.

   if (fFlip)
      SetState(fState);
}

//______________________________________________________________________________
void TGLCapabilitySwitch::SetState(Bool_t s)
{
   if (s)
      glEnable(fWhat);
   else
      glDisable(fWhat);
}


//______________________________________________________________________________
TGLCapabilityEnabler::TGLCapabilityEnabler(Int_t what, Bool_t state) :
   fWhat(what)
{
   // Constructor - change state only if necessary.

   fFlip = ! glIsEnabled(fWhat) && state;
   if (fFlip)
      glEnable(fWhat);
}

//______________________________________________________________________________
TGLCapabilityEnabler::~TGLCapabilityEnabler()
{
   // Destructor - reset state if changed.

   if (fFlip)
      glDisable(fWhat);
}


//______________________________________________________________________________
TGLFloatHolder::TGLFloatHolder(Int_t what, Float_t state, void (*foo)(Float_t)) :
      fWhat(what), fState(0), fFlip(kFALSE), fFoo(foo)
   {
      glGetFloatv(fWhat, &fState);
      fFlip = (fState != state);
      if (fFlip) fFoo(state);
   }

//______________________________________________________________________________
TGLFloatHolder::~TGLFloatHolder()
   {
      if (fFlip) fFoo(fState);
   }


//______________________________________________________________________________
TGLEnableGuard::TGLEnableGuard(Int_t cap)
                  : fCap(cap)
{
   // TGLEnableGuard constructor.
   glEnable(GLenum(fCap));
}

//______________________________________________________________________________
TGLEnableGuard::~TGLEnableGuard()
{
   // TGLEnableGuard destructor.
   glDisable(GLenum(fCap));
}

//______________________________________________________________________________
TGLDisableGuard::TGLDisableGuard(Int_t cap)
                  : fCap(cap)
{
   // TGLDisableGuard constructor.
   glDisable(GLenum(fCap));
}

//______________________________________________________________________________
TGLDisableGuard::~TGLDisableGuard()
{
   // TGLDisableGuard destructor.
   glEnable(GLenum(fCap));
}

ClassImp(TGLSelectionBuffer);

//______________________________________________________________________________
TGLSelectionBuffer::TGLSelectionBuffer()
                        : fWidth(0), fHeight(0)
{
   // TGLSelectionBuffer constructor.
}

//______________________________________________________________________________
TGLSelectionBuffer::~TGLSelectionBuffer()
{
   // TGLSelectionBuffer destructor.
}

//______________________________________________________________________________
void TGLSelectionBuffer::ReadColorBuffer(Int_t w, Int_t h)
{
   // Read color buffer.
   fWidth = w;
   fHeight = h;
   fBuffer.resize(w * h * 4);
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, &fBuffer[0]);
}

//______________________________________________________________________________
void TGLSelectionBuffer::ReadColorBuffer(Int_t x, Int_t y, Int_t w, Int_t h)
{
   // Read color buffer.
   fWidth = w;
   fHeight = h;
   fBuffer.resize(w * h * 4);
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   glReadPixels(x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, &fBuffer[0]);
}

//______________________________________________________________________________
const UChar_t *TGLSelectionBuffer::GetPixelColor(Int_t px, Int_t py)const
{
   // Get pixel color.
   if (px < 0)
      px = 0;
   if (py < 0)
      py = 0;

   if (UInt_t(px * fWidth * 4 + py * 4) > fBuffer.size())
      return &fBuffer[0];

   return &fBuffer[px * fWidth * 4 + py * 4];
}

namespace Rgl {

const Float_t gRedEmission[]    = {1.f, 0.f,  0.f, 1.f};
const Float_t gGreenEmission[]  = {0.f, 1.f,  0.f, 1.f};
const Float_t gBlueEmission[]   = {0.f, 0.f,  1.f, 1.f};
const Float_t gOrangeEmission[] = {1.f, 0.4f, 0.f, 1.f};
const Float_t gWhiteEmission[]  = {1.f, 1.f,  1.f, 1.f};
const Float_t gGrayEmission[]   = {0.3f,0.3f, 0.3f,1.f};
const Float_t gNullEmission[]   = {0.f, 0.f,  0.f, 1.f};

namespace {
   struct RGB_t {
      Int_t fRGB[3];
   };

   RGB_t gColorTriplets[] = {{{255, 0, 0}},
                              {{0, 255, 0}},
                              {{0, 0, 255}},
                              {{255, 255, 0}},
                              {{255, 0, 255}},
                              {{0, 255, 255}},
                              {{255, 255, 255}}};

   Bool_t operator < (const RGB_t &lhs, const RGB_t &rhs)
   {
      if (lhs.fRGB[0] < rhs.fRGB[0])
         return kTRUE;
      else if (lhs.fRGB[0] > rhs.fRGB[0])
         return kFALSE;
      else if (lhs.fRGB[1] < rhs.fRGB[1])
         return kTRUE;
      else if (lhs.fRGB[1] > rhs.fRGB[1])
         return kFALSE;
      else if (lhs.fRGB[2] < rhs.fRGB[2])
         return kTRUE;

      return kFALSE;
   }

   typedef std::map<Int_t, RGB_t> ColorLookupTable_t;
   typedef ColorLookupTable_t::const_iterator CLTCI_t;

   ColorLookupTable_t gObjectIDToColor;

   typedef std::map<RGB_t, Int_t> ObjectLookupTable_t;
   typedef ObjectLookupTable_t::const_iterator OLTCI_t;

   ObjectLookupTable_t gColorToObjectID;
}
//______________________________________________________________________________
void ObjectIDToColor(Int_t objectID, Bool_t highColor)
{
   //Object id encoded as rgb triplet.
   if (!highColor)
      glColor3ub(objectID & 0xff, (objectID & 0xff00) >> 8, (objectID & 0xff0000) >> 16);
   else {
      if (!gObjectIDToColor.size()) {
      //Initialize lookup tables.
         for (Int_t i = 0, id = 1; i < Int_t(sizeof gColorTriplets / sizeof(RGB_t)); ++i, ++id)
            gObjectIDToColor[id] = gColorTriplets[i];
         for (Int_t i = 0, id = 1; i < Int_t(sizeof gColorTriplets / sizeof(RGB_t)); ++i, ++id)
            gColorToObjectID[gColorTriplets[i]] = id;
      }

      CLTCI_t it = gObjectIDToColor.find(objectID);

      if (it != gObjectIDToColor.end())
         glColor3ub(it->second.fRGB[0], it->second.fRGB[1], it->second.fRGB[2]);
      else {
         Error("ObjectIDToColor", "No color for such object ID: %d", objectID);
         glColor3ub(0, 0, 0);
      }
   }
}

//______________________________________________________________________________
Int_t ColorToObjectID(const UChar_t *pixel, Bool_t highColor)
{
   if (!highColor)
      return pixel[0] | (pixel[1] << 8) | (pixel[2] << 16);
   else {
      if (!gObjectIDToColor.size())
         return 0;

      RGB_t triplet = {{pixel[0], pixel[1], pixel[2]}};
      OLTCI_t it = gColorToObjectID.find(triplet);

      if (it != gColorToObjectID.end())
         return it->second;
      else
         return 0;
   }
}


//______________________________________________________________________________
void DrawQuadOutline(const TGLVertex3 &v1, const TGLVertex3 &v2,
                     const TGLVertex3 &v3, const TGLVertex3 &v4)
{
   //Draw quad outline.
   glBegin(GL_LINE_LOOP);
   glVertex3dv(v1.CArr());
   glVertex3dv(v2.CArr());
   glVertex3dv(v3.CArr());
   glVertex3dv(v4.CArr());
   glEnd();
}

//______________________________________________________________________________
void DrawQuadFilled(const TGLVertex3 &v0, const TGLVertex3 &v1, const TGLVertex3 &v2,
                     const TGLVertex3 &v3, const TGLVector3 &normal)
{
   //Draw quad face.
   glBegin(GL_POLYGON);
   glNormal3dv(normal.CArr());
   glVertex3dv(v0.CArr());
   glVertex3dv(v1.CArr());
   glVertex3dv(v2.CArr());
   glVertex3dv(v3.CArr());
   glEnd();
}

//______________________________________________________________________________
void DrawQuadFilled(const Double_t *v0, const Double_t *v1, const Double_t *v2, const Double_t *v3,
                    const Double_t *normal)
{
   //Draw quad face.
   glBegin(GL_QUADS);
   glNormal3dv(normal);
   glVertex3dv(v0);
   glVertex3dv(v1);
   glVertex3dv(v2);
   glVertex3dv(v3);
   glEnd();
}

//______________________________________________________________________________
void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
                  const TGLVector3 &norm1, const TGLVector3 &norm2, const TGLVector3 &norm3)
{
   //Draws triangle face, each vertex has its own averaged normal
   glBegin(GL_POLYGON);
   glNormal3dv(norm1.CArr());
   glVertex3dv(v1.CArr());
   glNormal3dv(norm2.CArr());
   glVertex3dv(v2.CArr());
   glNormal3dv(norm3.CArr());
   glVertex3dv(v3.CArr());
   glEnd();
}

const Int_t    gBoxFrontQuads[][4] = {{0, 1, 2, 3}, {4, 0, 3, 5}, {4, 5, 6, 7}, {7, 6, 2, 1}};
const Double_t gBoxFrontNormals[][3] = {{-1., 0., 0.}, {0., -1., 0.}, {1., 0., 0.}, {0., 1., 0.}};
const Int_t    gBoxFrontPlanes[][2] = {{0, 1}, {1, 2}, {2, 3}, {3, 0}};

const Int_t    gBoxBackQuads[][4] = {{7, 1, 2, 6}, {4, 7, 6, 5}, {0, 4, 5, 3}, {0, 3, 2, 1}};
const Double_t gBoxBackNormals[][3] = {{0., -1., 0.}, {-1., 0., 0.}, {0., 1., 0.}, {1., 0., 0.}};
const Int_t    gBoxBackPlanes[][2] = {{0, 1}, {3, 0}, {2, 3}, {1, 2}};

//______________________________________________________________________________
void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
                  Double_t zMin, Double_t zMax, Int_t fp)
{
   //Draws lego's bar as a 3d box
   if (zMax < zMin)
      std::swap(zMax, zMin);

   //Bottom is always drawn.
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., -1.);
   glVertex3d(xMax, yMin, zMin);
   glVertex3d(xMin, yMin, zMin);
   glVertex3d(xMin, yMax, zMin);
   glVertex3d(xMax, yMax, zMin);
   glEnd();
   //Draw two visible front planes.
   const Double_t box[][3] = {{xMin, yMin, zMax}, {xMin, yMax, zMax}, {xMin, yMax, zMin}, {xMin, yMin, zMin},
                              {xMax, yMin, zMax}, {xMax, yMin, zMin}, {xMax, yMax, zMin}, {xMax, yMax, zMax}};
   const Int_t *verts = gBoxFrontQuads[gBoxFrontPlanes[fp][0]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxFrontNormals[gBoxFrontPlanes[fp][0]]);
   glVertex3dv(box[verts[0]]);
   glVertex3dv(box[verts[1]]);
   glVertex3dv(box[verts[2]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   verts = gBoxFrontQuads[gBoxFrontPlanes[fp][1]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxFrontNormals[gBoxFrontPlanes[fp][1]]);
   glVertex3dv(box[verts[0]]);
   glVertex3dv(box[verts[1]]);
   glVertex3dv(box[verts[2]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   //Top is always drawn.
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., 1.);
   glVertex3d(xMax, yMin, zMax);
   glVertex3d(xMax, yMax, zMax);
   glVertex3d(xMin, yMax, zMax);
   glVertex3d(xMin, yMin, zMax);
   glEnd();
}

//______________________________________________________________________________
void DrawTransparentBox(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax,
                        Double_t zMin, Double_t zMax, Int_t fp)
{
   //Draws lego's bar as a 3d box
   if (zMax < zMin)
      std::swap(zMax, zMin);

   //The order is: 1) two back planes, 2) bottom plane, 3) two front planes,
   //4) top.

   //Bottom is always drawn.
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., -1.);
   glVertex3d(xMax, yMin, zMin);
   glVertex3d(xMin, yMin, zMin);
   glVertex3d(xMin, yMax, zMin);
   glVertex3d(xMax, yMax, zMin);
   glEnd();

   const Double_t box[][3] = {{xMin, yMin, zMax}, {xMin, yMax, zMax}, {xMin, yMax, zMin}, {xMin, yMin, zMin},
                              {xMax, yMin, zMax}, {xMax, yMin, zMin}, {xMax, yMax, zMin}, {xMax, yMax, zMax}};

   //Draw two back planes.
   const Int_t *verts = gBoxBackQuads[gBoxBackPlanes[fp][0]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxBackNormals[gBoxBackPlanes[fp][0]]);
   glVertex3dv(box[verts[0]]);
   glVertex3dv(box[verts[1]]);
   glVertex3dv(box[verts[2]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   verts = gBoxBackQuads[gBoxBackPlanes[fp][1]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxBackNormals[gBoxBackPlanes[fp][1]]);
   glVertex3dv(box[verts[0]]);
   glVertex3dv(box[verts[1]]);
   glVertex3dv(box[verts[2]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   //Draw two visible front planes.
   verts = gBoxFrontQuads[gBoxFrontPlanes[fp][0]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxFrontNormals[gBoxFrontPlanes[fp][0]]);
   glVertex3dv(box[verts[0]]);
   glVertex3dv(box[verts[1]]);
   glVertex3dv(box[verts[2]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   verts = gBoxFrontQuads[gBoxFrontPlanes[fp][1]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxFrontNormals[gBoxFrontPlanes[fp][1]]);
   glVertex3dv(box[verts[0]]);
   glVertex3dv(box[verts[1]]);
   glVertex3dv(box[verts[2]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   //Top is always drawn.
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., 1.);
   glVertex3d(xMax, yMin, zMax);
   glVertex3d(xMax, yMax, zMax);
   glVertex3d(xMin, yMax, zMax);
   glVertex3d(xMin, yMin, zMax);
   glEnd();
}

//______________________________________________________________________________
void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,
                           Double_t yMax, Double_t zMin, Double_t zMax,
                           Double_t texMin, Double_t texMax, Int_t fp)
{
   //Draws lego's bar as a 3d box
   //LULULULU
   if (zMax < zMin) {
      std::swap(zMax, zMin);
      std::swap(texMax, texMin);
   }

   //Top and bottom are always drawn.
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., 1.);
   glTexCoord1d(texMax);
   glVertex3d(xMax, yMin, zMax);
   glVertex3d(xMax, yMax, zMax);
   glVertex3d(xMin, yMax, zMax);
   glVertex3d(xMin, yMin, zMax);
   glEnd();

   glBegin(GL_POLYGON);
   glTexCoord1d(texMin);
   glNormal3d(0., 0., -1.);
   glVertex3d(xMax, yMin, zMin);
   glVertex3d(xMin, yMin, zMin);
   glVertex3d(xMin, yMax, zMin);
   glVertex3d(xMax, yMax, zMin);
   glEnd();
   //Draw two visible front planes.
   const Double_t box[][3] = {{xMin, yMin, zMax}, {xMin, yMax, zMax}, {xMin, yMax, zMin}, {xMin, yMin, zMin},
                              {xMax, yMin, zMax}, {xMax, yMin, zMin}, {xMax, yMax, zMin}, {xMax, yMax, zMax}};

   const Double_t tex[] = {texMax, texMax, texMin, texMin, texMax, texMin, texMin, texMax};
   const Int_t *verts = gBoxFrontQuads[gBoxFrontPlanes[fp][0]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxFrontNormals[gBoxFrontPlanes[fp][0]]);
   glTexCoord1d(tex[verts[0]]);
   glVertex3dv(box[verts[0]]);
   glTexCoord1d(tex[verts[1]]);
   glVertex3dv(box[verts[1]]);
   glTexCoord1d(tex[verts[2]]);
   glVertex3dv(box[verts[2]]);
   glTexCoord1d(tex[verts[3]]);
   glVertex3dv(box[verts[3]]);
   glEnd();

   verts = gBoxFrontQuads[gBoxFrontPlanes[fp][1]];

   glBegin(GL_POLYGON);
   glNormal3dv(gBoxFrontNormals[gBoxFrontPlanes[fp][1]]);
   glTexCoord1d(tex[verts[0]]);
   glVertex3dv(box[verts[0]]);
   glTexCoord1d(tex[verts[1]]);
   glVertex3dv(box[verts[1]]);
   glTexCoord1d(tex[verts[2]]);
   glVertex3dv(box[verts[2]]);
   glTexCoord1d(tex[verts[3]]);
   glVertex3dv(box[verts[3]]);
   glEnd();
}

//______________________________________________________________________________
void DrawBoxWithGradientFill(Double_t y1, Double_t y2, Double_t x1, Double_t x2,
                             const Double_t *rgba1, const Double_t *rgba2)
{
   assert(rgba1 != 0 && "DrawBoxWithGradientFill, parameter 'rgba1' is null");
   assert(rgba2 != 0 && "DrawBoxWithGradientFill, parameter 'rgba2' is null");

   glBegin(GL_POLYGON);
   glColor4dv(rgba1);
   glVertex2d(x1, y1);
   glVertex2d(x2, y1);
   glColor4dv(rgba2);
   glVertex2d(x2, y2);
   glVertex2d(x1, y2);
   glEnd();
}

//______________________________________________________________________________
void DrawQuadStripWithRadialGradientFill(unsigned nPoints, const Double_t *inner, const Double_t *innerRGBA,
                                         const Double_t *outer, const Double_t *outerRGBA)
{
   //TODO: is it possible to use GLdouble to avoid problems with Double_t/GLdouble if they
   //are not the same type?

   assert(nPoints != 0 &&
          "DrawQuadStripWithRadialGradientFill, invalid number of points");
   assert(inner != 0 &&
          "DrawQuadStripWithRadialGradientFill, parameter 'inner' is null");
   assert(innerRGBA != 0 &&
          "DrawQuadStripWithRadialGradientFill, parameter 'innerRGBA' is null");
   assert(outer != 0 &&
          "DrawQuadStripWithRadialGradientFill, parameter 'outer' is null");
   assert(outerRGBA != 0 &&
          "DrawQuadStripWithRadialGradientFill, parameter 'outerRGBA' is null");

   glBegin(GL_QUAD_STRIP);
   for (UInt_t j = 0; j < nPoints; ++j) {
      glColor4dv(innerRGBA);
      glVertex2dv(inner + j * 2);
      glColor4dv(outerRGBA);
      glVertex2dv(outer + j * 2);
   }
   glEnd();
}

//______________________________________________________________________________
void DrawCylinder(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
                  Double_t yMax, Double_t zMin, Double_t zMax)
{
   //Cylinder for lego3.
   GLUquadric *quad = quadric->Get();

   if (quad) {
      if (zMin > zMax)
         std::swap(zMin, zMax);
      const Double_t xCenter = xMin + (xMax - xMin) / 2;
      const Double_t yCenter = yMin + (yMax - yMin) / 2;
      const Double_t radius = TMath::Min((xMax - xMin) / 2, (yMax - yMin) / 2);

      glPushMatrix();
      glTranslated(xCenter, yCenter, zMin);
      gluCylinder(quad, radius, radius, zMax - zMin, 40, 1);
      glPopMatrix();
      glPushMatrix();
      glTranslated(xCenter, yCenter, zMax);
      gluDisk(quad, 0., radius, 40, 1);
      glPopMatrix();
      glPushMatrix();
      glTranslated(xCenter, yCenter, zMin);
      glRotated(180., 0., 1., 0.);
      gluDisk(quad, 0., radius, 40, 1);
      glPopMatrix();
   }
}

//______________________________________________________________________________
void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin,
                  Double_t yMax, Double_t zMin, Double_t zMax)
{
   //Cylinder for lego3.
   GLUquadric *quad = quadric->Get();

   if (quad) {
      const Double_t xCenter = xMin + (xMax - xMin) / 2;
      const Double_t yCenter = yMin + (yMax - yMin) / 2;
      const Double_t zCenter = zMin + (zMax - zMin) / 2;

      const Double_t radius = TMath::Min((zMax - zMin) / 2,
                                          TMath::Min((xMax - xMin) / 2, (yMax - yMin) / 2));

      glPushMatrix();
      glTranslated(xCenter, yCenter, zCenter);
      gluSphere(quad, radius, 10, 10);
      glPopMatrix();
   }
}


//______________________________________________________________________________
void DrawError(Double_t xMin, Double_t xMax, Double_t yMin,
               Double_t yMax, Double_t zMin, Double_t zMax)
{
   const Double_t xWid = xMax - xMin;
   const Double_t yWid = yMax - yMin;

   glBegin(GL_LINES);
   glVertex3d(xMin + xWid / 2, yMin + yWid / 2, zMin);
   glVertex3d(xMin + xWid / 2, yMin + yWid / 2, zMax);
   glEnd();

   glBegin(GL_LINES);
   glVertex3d(xMin + xWid / 2, yMin, zMin);
   glVertex3d(xMin + xWid / 2, yMax, zMin);
   glEnd();

   glBegin(GL_LINES);
   glVertex3d(xMin, yMin + yWid / 2, zMin);
   glVertex3d(xMax, yMin + yWid / 2, zMin);
   glEnd();
}

void CylindricalNormal(const Double_t *v, Double_t *normal)
{
   const Double_t n = TMath::Sqrt(v[0] * v[0] + v[1] * v[1]);
   if (n > 0.) {
      normal[0] = v[0] / n;
      normal[1] = v[1] / n;
      normal[2] = 0.;
   } else {
      normal[0] = v[0];
      normal[1] = v[1];
      normal[2] = 0.;
   }
}

void CylindricalNormalInv(const Double_t *v, Double_t *normal)
{
   const Double_t n = TMath::Sqrt(v[0] * v[0] + v[1] * v[1]);
   if (n > 0.) {
      normal[0] = -v[0] / n;
      normal[1] = -v[1] / n;
      normal[2] = 0.;
   } else {
      normal[0] = -v[0];
      normal[1] = -v[1];
      normal[2] = 0.;
   }
}

void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color)
{
   //In polar coordinates, box became trapezoid.
   //Four faces need normal calculations.
   if (zMin > zMax)
      std::swap(zMin, zMax);
   //top
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., 1.);
   glVertex3d(ver[0][0], ver[0][1], zMax);
   glVertex3d(ver[1][0], ver[1][1], zMax);
   glVertex3d(ver[2][0], ver[2][1], zMax);
   glVertex3d(ver[3][0], ver[3][1], zMax);
   glEnd();
   //bottom
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., -1.);
   glVertex3d(ver[0][0], ver[0][1], zMin);
   glVertex3d(ver[3][0], ver[3][1], zMin);
   glVertex3d(ver[2][0], ver[2][1], zMin);
   glVertex3d(ver[1][0], ver[1][1], zMin);
   glEnd();
   //

   Double_t trapezoid[][3] = {{ver[0][0], ver[0][1], zMin}, {ver[1][0], ver[1][1], zMin},
                              {ver[2][0], ver[2][1], zMin}, {ver[3][0], ver[3][1], zMin},
                              {ver[0][0], ver[0][1], zMax}, {ver[1][0], ver[1][1], zMax},
                              {ver[2][0], ver[2][1], zMax}, {ver[3][0], ver[3][1], zMax}};
   Double_t normal[3] = {0.};
   glBegin(GL_POLYGON);
   CylindricalNormal(trapezoid[1], normal), glNormal3dv(normal), glVertex3dv(trapezoid[1]);
   CylindricalNormal(trapezoid[2], normal), glNormal3dv(normal), glVertex3dv(trapezoid[2]);
   CylindricalNormal(trapezoid[6], normal), glNormal3dv(normal), glVertex3dv(trapezoid[6]);
   CylindricalNormal(trapezoid[5], normal), glNormal3dv(normal), glVertex3dv(trapezoid[5]);
   glEnd();

   glBegin(GL_POLYGON);
   CylindricalNormalInv(trapezoid[0], normal), glNormal3dv(normal), glVertex3dv(trapezoid[0]);
   CylindricalNormalInv(trapezoid[4], normal), glNormal3dv(normal), glVertex3dv(trapezoid[4]);
   CylindricalNormalInv(trapezoid[7], normal), glNormal3dv(normal), glVertex3dv(trapezoid[7]);
   CylindricalNormalInv(trapezoid[3], normal), glNormal3dv(normal), glVertex3dv(trapezoid[3]);
   glEnd();

   glBegin(GL_POLYGON);
   if (color) {
      TMath::Normal2Plane(trapezoid[0], trapezoid[1], trapezoid[5], normal);
      glNormal3dv(normal);
   }
   glVertex3dv(trapezoid[0]);
   glVertex3dv(trapezoid[1]);
   glVertex3dv(trapezoid[5]);
   glVertex3dv(trapezoid[4]);
   glEnd();

   glBegin(GL_POLYGON);
   if (color) {
      TMath::Normal2Plane(trapezoid[3], trapezoid[7], trapezoid[6], normal);
      glNormal3dv(normal);
   }
   glVertex3dv(trapezoid[3]);
   glVertex3dv(trapezoid[7]);
   glVertex3dv(trapezoid[6]);
   glVertex3dv(trapezoid[2]);
   glEnd();
}

//______________________________________________________________________________
void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,
                           Double_t texMin, Double_t texMax)
{
   //In polar coordinates, box became trapezoid.
   //Four faces need normal calculations.
   if (zMin > zMax) {
      std::swap(zMin, zMax);
      std::swap(texMin, texMax);
   }

   //top
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., 1.);
   glTexCoord1d(texMax);
   glVertex3d(ver[0][0], ver[0][1], zMax);
   glVertex3d(ver[1][0], ver[1][1], zMax);
   glVertex3d(ver[2][0], ver[2][1], zMax);
   glVertex3d(ver[3][0], ver[3][1], zMax);
   glEnd();
   //bottom
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., -1.);
   glTexCoord1d(texMin);
   glVertex3d(ver[0][0], ver[0][1], zMin);
   glVertex3d(ver[3][0], ver[3][1], zMin);
   glVertex3d(ver[2][0], ver[2][1], zMin);
   glVertex3d(ver[1][0], ver[1][1], zMin);
   glEnd();
   //

   Double_t trapezoid[][3] = {{ver[0][0], ver[0][1], zMin}, {ver[1][0], ver[1][1], zMin},
                              {ver[2][0], ver[2][1], zMin}, {ver[3][0], ver[3][1], zMin},
                              {ver[0][0], ver[0][1], zMax}, {ver[1][0], ver[1][1], zMax},
                              {ver[2][0], ver[2][1], zMax}, {ver[3][0], ver[3][1], zMax}};
   Double_t normal[3] = {0.};
   glBegin(GL_POLYGON);
   CylindricalNormal(trapezoid[1], normal), glNormal3dv(normal), glTexCoord1d(texMin), glVertex3dv(trapezoid[1]);
   CylindricalNormal(trapezoid[2], normal), glNormal3dv(normal), glTexCoord1d(texMin), glVertex3dv(trapezoid[2]);
   CylindricalNormal(trapezoid[6], normal), glNormal3dv(normal), glTexCoord1d(texMax), glVertex3dv(trapezoid[6]);
   CylindricalNormal(trapezoid[5], normal), glNormal3dv(normal), glTexCoord1d(texMax), glVertex3dv(trapezoid[5]);
   glEnd();

   glBegin(GL_POLYGON);
   CylindricalNormalInv(trapezoid[0], normal), glNormal3dv(normal), glTexCoord1d(texMin), glVertex3dv(trapezoid[0]);
   CylindricalNormalInv(trapezoid[4], normal), glNormal3dv(normal), glTexCoord1d(texMax), glVertex3dv(trapezoid[4]);
   CylindricalNormalInv(trapezoid[7], normal), glNormal3dv(normal), glTexCoord1d(texMax), glVertex3dv(trapezoid[7]);
   CylindricalNormalInv(trapezoid[3], normal), glNormal3dv(normal), glTexCoord1d(texMin), glVertex3dv(trapezoid[3]);
   glEnd();

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(trapezoid[0], trapezoid[1], trapezoid[5], normal);
   glNormal3dv(normal);
   glTexCoord1d(texMin);
   glVertex3dv(trapezoid[0]);
   glTexCoord1d(texMin);
   glVertex3dv(trapezoid[1]);
   glTexCoord1d(texMax);
   glVertex3dv(trapezoid[5]);
   glTexCoord1d(texMax);
   glVertex3dv(trapezoid[4]);
   glEnd();

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(trapezoid[3], trapezoid[7], trapezoid[6], normal);
   glNormal3dv(normal);
   glTexCoord1d(texMin);
   glVertex3dv(trapezoid[3]);
   glTexCoord1d(texMax);
   glVertex3dv(trapezoid[7]);
   glTexCoord1d(texMax);
   glVertex3dv(trapezoid[6]);
   glTexCoord1d(texMin);
   glVertex3dv(trapezoid[2]);
   glEnd();
}

//______________________________________________________________________________
void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax,
                              Double_t texMin, Double_t texMax)
{
   //In polar coordinates, box became trapezoid.
   if (zMin > zMax)
      std::swap(zMin, zMax);

   const Double_t trapezoid[][3] = {{ver[0][0], ver[0][1], zMin}, {ver[1][0], ver[1][1], zMin},
                                    {ver[2][0], ver[2][1], zMin}, {ver[3][0], ver[3][1], zMin},
                                    {ver[0][0], ver[0][1], zMax}, {ver[1][0], ver[1][1], zMax},
                                    {ver[2][0], ver[2][1], zMax}, {ver[3][0], ver[3][1], zMax}};
   const Double_t tex[] = {texMin, texMax, texMax, texMin, texMin, texMax, texMax, texMin};
   //top
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., 1.);
   glTexCoord1d(tex[4]), glVertex3dv(trapezoid[4]);
   glTexCoord1d(tex[5]), glVertex3dv(trapezoid[5]);
   glTexCoord1d(tex[6]), glVertex3dv(trapezoid[6]);
   glTexCoord1d(tex[7]), glVertex3dv(trapezoid[7]);
   glEnd();
   //bottom
   glBegin(GL_POLYGON);
   glNormal3d(0., 0., -1.);
   glTexCoord1d(tex[0]), glVertex3dv(trapezoid[0]);
   glTexCoord1d(tex[3]), glVertex3dv(trapezoid[3]);
   glTexCoord1d(tex[2]), glVertex3dv(trapezoid[2]);
   glTexCoord1d(tex[1]), glVertex3dv(trapezoid[1]);
   glEnd();
   //
   glBegin(GL_POLYGON);
   Double_t normal[3] = {};
   CylindricalNormal(trapezoid[1], normal), glNormal3dv(normal), glTexCoord1d(tex[1]), glVertex3dv(trapezoid[1]);
   CylindricalNormal(trapezoid[2], normal), glNormal3dv(normal), glTexCoord1d(tex[2]), glVertex3dv(trapezoid[2]);
   CylindricalNormal(trapezoid[6], normal), glNormal3dv(normal), glTexCoord1d(tex[6]), glVertex3dv(trapezoid[6]);
   CylindricalNormal(trapezoid[5], normal), glNormal3dv(normal), glTexCoord1d(tex[5]), glVertex3dv(trapezoid[5]);
   glEnd();

   glBegin(GL_POLYGON);
   CylindricalNormalInv(trapezoid[0], normal), glNormal3dv(normal), glTexCoord1d(tex[0]), glVertex3dv(trapezoid[0]);
   CylindricalNormalInv(trapezoid[4], normal), glNormal3dv(normal), glTexCoord1d(tex[4]), glVertex3dv(trapezoid[4]);
   CylindricalNormalInv(trapezoid[7], normal), glNormal3dv(normal), glTexCoord1d(tex[7]), glVertex3dv(trapezoid[7]);
   CylindricalNormalInv(trapezoid[3], normal), glNormal3dv(normal), glTexCoord1d(tex[3]), glVertex3dv(trapezoid[3]);
   glEnd();

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(trapezoid[0], trapezoid[1], trapezoid[5], normal);
   glNormal3dv(normal);
   glTexCoord1d(tex[0]), glVertex3dv(trapezoid[0]);
   glTexCoord1d(tex[1]), glVertex3dv(trapezoid[1]);
   glTexCoord1d(tex[5]), glVertex3dv(trapezoid[5]);
   glTexCoord1d(tex[4]), glVertex3dv(trapezoid[4]);
   glEnd();

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(trapezoid[3], trapezoid[7], trapezoid[6], normal);
   glNormal3dv(normal);
   glTexCoord1d(tex[3]), glVertex3dv(trapezoid[3]);
   glTexCoord1d(tex[7]), glVertex3dv(trapezoid[7]);
   glTexCoord1d(tex[6]), glVertex3dv(trapezoid[6]);
   glTexCoord1d(tex[2]), glVertex3dv(trapezoid[2]);
   glEnd();
}

//______________________________________________________________________________
void SphericalNormal(const Double_t *v, Double_t *normal)
{
   const Double_t n = TMath::Sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
   if (n > 0.) {
      normal[0] = v[0] / n;
      normal[1] = v[1] / n;
      normal[2] = v[2] / n;
   } else {
      normal[0] = v[0];
      normal[1] = v[1];
      normal[2] = v[2];
   }
}

//______________________________________________________________________________
void SphericalNormalInv(const Double_t *v, Double_t *normal)
{
   const Double_t n = TMath::Sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
   if (n > 0.) {
      normal[0] = -v[0] / n;
      normal[1] = -v[1] / n;
      normal[2] = -v[2] / n;
   } else {
      normal[0] = -v[0];
      normal[1] = -v[1];
      normal[2] = -v[2];
   }
}

//______________________________________________________________________________
void DrawTrapezoid(const Double_t ver[][3])
{
   Double_t normal[3] = {0.};

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[1], ver[2], ver[3], normal);
   glNormal3dv(normal);
   glVertex3dv(ver[0]);
   glVertex3dv(ver[1]);
   glVertex3dv(ver[2]);
   glVertex3dv(ver[3]);
   glEnd();
   //bottom
   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[4], ver[7], ver[6], normal);
   glNormal3dv(normal);
   glVertex3dv(ver[4]);
   glVertex3dv(ver[7]);
   glVertex3dv(ver[6]);
   glVertex3dv(ver[5]);
   glEnd();
   //

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[0], ver[3], ver[7], normal);
   glNormal3dv(normal);
   glVertex3dv(ver[0]);
   glVertex3dv(ver[3]);
   glVertex3dv(ver[7]);
   glVertex3dv(ver[4]);
   glEnd();

   glBegin(GL_POLYGON);
   SphericalNormal(ver[3], normal), glNormal3dv(normal), glVertex3dv(ver[3]);
   SphericalNormal(ver[2], normal), glNormal3dv(normal), glVertex3dv(ver[2]);
   SphericalNormal(ver[6], normal), glNormal3dv(normal), glVertex3dv(ver[6]);
   SphericalNormal(ver[7], normal), glNormal3dv(normal), glVertex3dv(ver[7]);
   glEnd();

   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[5], ver[6], ver[2], normal);
   glNormal3dv(normal);
   glVertex3dv(ver[5]);
   glVertex3dv(ver[6]);
   glVertex3dv(ver[2]);
   glVertex3dv(ver[1]);
   glEnd();

   glBegin(GL_POLYGON);
   SphericalNormalInv(ver[0], normal), glNormal3dv(normal), glVertex3dv(ver[0]);
   SphericalNormalInv(ver[4], normal), glNormal3dv(normal), glVertex3dv(ver[4]);
   SphericalNormalInv(ver[5], normal), glNormal3dv(normal), glVertex3dv(ver[5]);
   SphericalNormalInv(ver[1], normal), glNormal3dv(normal), glVertex3dv(ver[1]);
   glEnd();
}

//______________________________________________________________________________
void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double_t texMax)
{
   Double_t normal[3] = {};
   if (texMin > texMax)
      std::swap(texMin, texMax);

   const Double_t tex[] = {texMin, texMin, texMax, texMax, texMin, texMin, texMax, texMax};
   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[0], ver[1], ver[2], normal);
   glNormal3dv(normal);
   glTexCoord1d(tex[0]), glVertex3dv(ver[0]);
   glTexCoord1d(tex[1]), glVertex3dv(ver[1]);
   glTexCoord1d(tex[2]), glVertex3dv(ver[2]);
   glTexCoord1d(tex[3]), glVertex3dv(ver[3]);
   glEnd();
   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[4], ver[7], ver[6], normal);
   glNormal3dv(normal);
   glTexCoord1d(tex[4]), glVertex3dv(ver[4]);
   glTexCoord1d(tex[7]), glVertex3dv(ver[7]);
   glTexCoord1d(tex[6]), glVertex3dv(ver[6]);
   glTexCoord1d(tex[5]), glVertex3dv(ver[5]);
   glEnd();
   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[0], ver[3], ver[7], normal);
   glNormal3dv(normal);
   glTexCoord1d(tex[0]), glVertex3dv(ver[0]);
   glTexCoord1d(tex[3]), glVertex3dv(ver[3]);
   glTexCoord1d(tex[7]), glVertex3dv(ver[7]);
   glTexCoord1d(tex[4]), glVertex3dv(ver[4]);
   glEnd();
   glBegin(GL_POLYGON);
   SphericalNormal(ver[3], normal), glNormal3dv(normal), glTexCoord1d(tex[3]), glVertex3dv(ver[3]);
   SphericalNormal(ver[2], normal), glNormal3dv(normal), glTexCoord1d(tex[2]), glVertex3dv(ver[2]);
   SphericalNormal(ver[6], normal), glNormal3dv(normal), glTexCoord1d(tex[6]), glVertex3dv(ver[6]);
   SphericalNormal(ver[7], normal), glNormal3dv(normal), glTexCoord1d(tex[7]), glVertex3dv(ver[7]);
   glEnd();
   glBegin(GL_POLYGON);
   TMath::Normal2Plane(ver[5], ver[6], ver[2], normal);
   glNormal3dv(normal);
   glTexCoord1d(tex[5]), glVertex3dv(ver[5]);
   glTexCoord1d(tex[6]), glVertex3dv(ver[6]);
   glTexCoord1d(tex[2]), glVertex3dv(ver[2]);
   glTexCoord1d(tex[1]), glVertex3dv(ver[1]);
   glEnd();
   glBegin(GL_POLYGON);
   SphericalNormalInv(ver[0], normal), glNormal3dv(normal), glTexCoord1d(tex[0]), glVertex3dv(ver[0]);
   SphericalNormalInv(ver[4], normal), glNormal3dv(normal), glTexCoord1d(tex[4]), glVertex3dv(ver[4]);
   SphericalNormalInv(ver[5], normal), glNormal3dv(normal), glTexCoord1d(tex[5]), glVertex3dv(ver[5]);
   SphericalNormalInv(ver[1], normal), glNormal3dv(normal), glTexCoord1d(tex[1]), glVertex3dv(ver[1]);
   glEnd();
}


void Draw2DAxis(TAxis *axis, Double_t xMin, Double_t yMin, Double_t xMax, Double_t yMax,
               Double_t min, Double_t max, Bool_t log, Bool_t z = kFALSE)
{
   //Axes are drawn with help of TGaxis class
   std::string option;
   option.reserve(20);

   if (xMin > xMax || z) option += "SDH=+";
   else option += "SDH=-";

   if (log) option += 'G';

   Int_t nDiv = axis->GetNdivisions();

   if (nDiv < 0) {
      option += 'N';
      nDiv = -nDiv;
   }

   TGaxis axisPainter;
   axisPainter.SetLineWidth(1);

   static const Double_t zero = 0.001;

   if (TMath::Abs(xMax - xMin) >= zero || TMath::Abs(yMax - yMin) >= zero) {
      axisPainter.ImportAxisAttributes(axis);
      axisPainter.SetLabelOffset(axis->GetLabelOffset() + axis->GetTickLength());

      if (log) {
         min = TMath::Power(10, min);
         max = TMath::Power(10, max);
      }
      //Option time display is required ?
      if (axis->GetTimeDisplay()) {
         option += 't';

         if (!strlen(axis->GetTimeFormatOnly()))
            axisPainter.SetTimeFormat(axis->ChooseTimeFormat(max - min));
         else
            axisPainter.SetTimeFormat(axis->GetTimeFormat());
      }

      axisPainter.SetOption(option.c_str());
      axisPainter.PaintAxis(xMin, yMin, xMax, yMax, min, max, nDiv, option.c_str());
   }
}

const Int_t gFramePoints[][2] = {{3, 1}, {0, 2}, {1, 3}, {2, 0}};
//Each point has two "neighbouring axes" (left and right). Axes types are 1 (ordinata) and 0 (abscissa)
const Int_t gAxisType[][2]    = {{1, 0}, {0, 1}, {1, 0}, {0, 1}};

//______________________________________________________________________________
void DrawAxes(Int_t fp, const Int_t *vp, const TGLVertex3 *box, const TGLPlotCoordinates *coord,
               TAxis *xAxis, TAxis *yAxis, TAxis *zAxis)
{
   //Using front point, find, where to draw axes and which labels to use for them
   //gVirtualX->SelectWindow(gGLManager->GetVirtualXInd(fGLDevice));
   //gVirtualX->SetDrawMode(TVirtualX::kCopy);//TCanvas by default sets in kInverse

   const Int_t left  = gFramePoints[fp][0];
   const Int_t right = gFramePoints[fp][1];
   const Double_t xLeft = gPad->AbsPixeltoX(Int_t(gPad->GetXlowNDC() * gPad->GetWw()
                                             + box[left].X() - vp[0]));
   const Double_t yLeft = gPad->AbsPixeltoY(Int_t(vp[3] - box[left].Y()
                                             + (1 - gPad->GetHNDC() - gPad->GetYlowNDC())
                                             * gPad->GetWh() + vp[1]));
   const Double_t xMid = gPad->AbsPixeltoX(Int_t(gPad->GetXlowNDC() * gPad->GetWw()
                                             + box[fp].X()  - vp[0]));
   const Double_t yMid = gPad->AbsPixeltoY(Int_t(vp[3] - box[fp].Y()
                                             + (1 - gPad->GetHNDC() - gPad->GetYlowNDC())
                                             * gPad->GetWh() + vp[1]));
   const Double_t xRight = gPad->AbsPixeltoX(Int_t(gPad->GetXlowNDC()
                                             * gPad->GetWw() + box[right].X() - vp[0]));
   const Double_t yRight = gPad->AbsPixeltoY(Int_t(vp[3] - box[right].Y()
                                             + (1 - gPad->GetHNDC() - gPad->GetYlowNDC())
                                             * gPad->GetWh() + vp[1]));
   const Double_t points[][2] = {{coord->GetXRange().first,  coord->GetYRange().first },
                                 {coord->GetXRange().second, coord->GetYRange().first },
                                 {coord->GetXRange().second, coord->GetYRange().second},
                                 {coord->GetXRange().first,  coord->GetYRange().second}};
   const Int_t    leftType      = gAxisType[fp][0];
   const Int_t    rightType     = gAxisType[fp][1];
   const Double_t leftLabel     = points[left][leftType];
   const Double_t leftMidLabel  = points[fp][leftType];
   const Double_t rightMidLabel = points[fp][rightType];
   const Double_t rightLabel    = points[right][rightType];

   if (xLeft - xMid || yLeft - yMid) {//To supress error messages from TGaxis
      TAxis *axis = leftType ? yAxis : xAxis;
      if (leftLabel < leftMidLabel)
         Draw2DAxis(axis, xLeft, yLeft, xMid, yMid, leftLabel, leftMidLabel,
                     leftType ? coord->GetYLog() : coord->GetXLog());
      else
         Draw2DAxis(axis, xMid, yMid, xLeft, yLeft, leftMidLabel, leftLabel,
                     leftType ? coord->GetYLog() : coord->GetXLog());
   }

   if (xRight - xMid || yRight - yMid) {//To supress error messages from TGaxis
      TAxis *axis = rightType ? yAxis : xAxis;

      if (rightMidLabel < rightLabel)
         Draw2DAxis(axis, xMid, yMid, xRight, yRight, rightMidLabel, rightLabel,
                     rightType ? coord->GetYLog() : coord->GetXLog());
      else
         Draw2DAxis(axis, xRight, yRight, xMid, yMid, rightLabel, rightMidLabel,
                     rightType ? coord->GetYLog() : coord->GetXLog());
   }

   const Double_t xUp = gPad->AbsPixeltoX(Int_t(gPad->GetXlowNDC() * gPad->GetWw()
                                          + box[left + 4].X() - vp[0]));
   const Double_t yUp = gPad->AbsPixeltoY(Int_t(vp[3] - box[left + 4].Y()
                                          + (1 - gPad->GetHNDC() - gPad->GetYlowNDC())
                                          * gPad->GetWh() + vp[1]));
   Draw2DAxis(zAxis, xLeft, yLeft, xUp, yUp, coord->GetZRange().first,
               coord->GetZRange().second, coord->GetZLog(), kTRUE);
}

void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax,
                  Double_t zScale, std::vector<Double_t> &zLevels)
{
   Int_t nDiv = zAxis->GetNdivisions() % 100;
   Int_t nBins = 0;
   Double_t binLow = 0., binHigh = 0., binWidth = 0.;
   THLimitsFinder::Optimize(zMin, zMax, nDiv, binLow, binHigh, nBins, binWidth, " ");
   zLevels.resize(nBins + 1);

   for (Int_t i = 0; i < nBins + 1; ++i)
      zLevels[i] = (binLow + i * binWidth) * zScale;
}

//______________________________________________________________________________
void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
                        Double_t t1, Double_t t2, Double_t t3, const TGLVector3 &norm1,
                        const TGLVector3 &norm2, const TGLVector3 &norm3)
{
   //Draw textured triangle

   glBegin(GL_POLYGON);
   glNormal3dv(norm1.CArr());
   glTexCoord1d(t1);
   glVertex3dv(v1.CArr());
   glNormal3dv(norm2.CArr());
   glTexCoord1d(t2);
   glVertex3dv(v2.CArr());
   glNormal3dv(norm3.CArr());
   glTexCoord1d(t3);
   glVertex3dv(v3.CArr());
   glEnd();
}

//______________________________________________________________________________
void DrawFaceTextured(const TGLVertex3 &v1, const TGLVertex3 &v2, const TGLVertex3 &v3,
                        Double_t t1, Double_t t2, Double_t t3, Double_t z,
                        const TGLVector3 &normal)
{
   //Draw textured triangle on a plane
   glBegin(GL_POLYGON);
   glNormal3dv(normal.CArr());
   glTexCoord1d(t1);
   glVertex3d(v1.X(), v1.Y(), z);
   glTexCoord1d(t2);
   glVertex3d(v2.X(), v2.Y(), z);
   glTexCoord1d(t3);
   glVertex3d(v3.X(), v3.Y(), z);
   glEnd();
}

//______________________________________________________________________________
void GetColor(Float_t v, Float_t vmin, Float_t vmax, Int_t type, Float_t *rgba)
{
   //This function creates color for parametric surface's vertex,
   //using its 'u' value.
   //I've found it in one of Apple's Carbon tutorials , and it's based
   //on Paul Bourke work. Very nice colors!!! :)
   Float_t dv,vmid;
   //Float_t c[] = {1.f, 1.f, 1.f};
   Float_t c1[3] = {}, c2[3] = {}, c3[3] = {};
   Float_t ratio ;
   rgba[3] = 1.f;

   if (v < vmin)
      v = vmin;
   if (v > vmax)
      v = vmax;
   dv = vmax - vmin;

   switch (type) {
   case 0:
      rgba[0] = 1.f;
      rgba[1] = 1.f;
      rgba[2] = 1.f;
   break;
   case 1:
   if (v < (vmin + 0.25 * dv)) {
      rgba[0] = 0;
      rgba[1] = 4 * (v - vmin) / dv;
      rgba[2] = 1;
   } else if (v < (vmin + 0.5 * dv)) {
      rgba[0] = 0;
      rgba[1] = 1;
      rgba[2] = 1 + 4 * (vmin + 0.25 * dv - v) / dv;
   } else if (v < (vmin + 0.75 * dv)) {
      rgba[0] = 4 * (v - vmin - 0.5 * dv) / dv;
      rgba[1] = 1;
      rgba[2] = 0;
   } else {
      rgba[0] = 1;
      rgba[1] = 1 + 4 * (vmin + 0.75 * dv - v) / dv;
      rgba[2] = 0;
   }
   break;
   case 2:
      rgba[0] = (v - vmin) / dv;
      rgba[1] = 0;
      rgba[2] = (vmax - v) / dv;
      break;
   case 3:
      rgba[0] = (v - vmin) / dv;
      rgba[1] = rgba[0];
      rgba[2] = rgba[0];
      break;
   case 4:
      if (v < (vmin + dv / 6.0)) {
         rgba[0] = 1;
         rgba[1] = 6 * (v - vmin) / dv;
         rgba[2] = 0;
      } else if (v < (vmin + 2.0 * dv / 6.0)) {
         rgba[0] = 1 + 6 * (vmin + dv / 6.0 - v) / dv;
         rgba[1] = 1;
         rgba[2] = 0;
      } else if (v < (vmin + 3.0 * dv / 6.0)) {
         rgba[0] = 0;
         rgba[1] = 1;
         rgba[2] = 6 * (v - vmin - 2.0 * dv / 6.0) / dv;
      } else if (v < (vmin + 4.0 * dv / 6.0)) {
         rgba[0] = 0;
         rgba[1] = 1 + 6 * (vmin + 3.0 * dv / 6.0 - v) / dv;
         rgba[2] = 1;
      } else if (v < (vmin + 5.0 * dv / 6.0)) {
         rgba[0] = 6 * (v - vmin - 4.0 * dv / 6.0) / dv;
         rgba[1] = 0;
         rgba[2] = 1;
      } else {
         rgba[0] = 1;
         rgba[1] = 0;
         rgba[2] = 1 + 6 * (vmin + 5.0 * dv / 6.0 - v) / dv;
      }
      break;
   case 5:
      rgba[0] = (v - vmin) / (vmax - vmin);
      rgba[1] = 1;
      rgba[2] = 0;
      break;
   case 6:
      rgba[0] = (v - vmin) / (vmax - vmin);
      rgba[1] = (vmax - v) / (vmax - vmin);
      rgba[2] = rgba[0];
      break;
   case 7:
      if (v < (vmin + 0.25 * dv)) {
         rgba[0] = 0;
         rgba[1] = 4 * (v - vmin) / dv;
         rgba[2] = 1 - rgba[1];
      } else if (v < (vmin + 0.5 * dv)) {
         rgba[0] = 4 * (v - vmin - 0.25 * dv) / dv;
         rgba[1] = 1 - rgba[0];
         rgba[2] = 0;
      } else if (v < (vmin + 0.75 * dv)) {
         rgba[1] = 4 * (v - vmin - 0.5 * dv) / dv;
         rgba[0] = 1 - rgba[1];
         rgba[2] = 0;
      } else {
         rgba[0] = 0;
         rgba[2] = 4 * (v - vmin - 0.75 * dv) / dv;
         rgba[1] = 1 - rgba[2];
      }
      break;
   case 8:
      if (v < (vmin + 0.5 * dv)) {
         rgba[0] = 2 * (v - vmin) / dv;
         rgba[1] = rgba[0];
         rgba[2] = rgba[0];
      } else {
         rgba[0] = 1 - 2 * (v - vmin - 0.5 * dv) / dv;
         rgba[1] = rgba[0];
         rgba[2] = rgba[0];
      }
      break;
   case 9:
      if (v < (vmin + dv / 3)) {
         rgba[2] = 3 * (v - vmin) / dv;
         rgba[1] = 0;
         rgba[0] = 1 - rgba[2];
      } else if (v < (vmin + 2 * dv / 3)) {
         rgba[0] = 0;
         rgba[1] = 3 * (v - vmin - dv / 3) / dv;
         rgba[2] = 1;
      } else {
         rgba[0] = 3 * (v - vmin - 2 * dv / 3) / dv;
         rgba[1] = 1 - rgba[0];
         rgba[2] = 1;
      }
      break;
   case 10:
      if (v < (vmin + 0.2 * dv)) {
         rgba[0] = 0;
         rgba[1] = 5 * (v - vmin) / dv;
         rgba[2] = 1;
      } else if (v < (vmin + 0.4 * dv)) {
         rgba[0] = 0;
         rgba[1] = 1;
         rgba[2] = 1 + 5 * (vmin + 0.2 * dv - v) / dv;
      } else if (v < (vmin + 0.6 * dv)) {
         rgba[0] = 5 * (v - vmin - 0.4 * dv) / dv;
         rgba[1] = 1;
         rgba[2] = 0;
      } else if (v < (vmin + 0.8 * dv)) {
         rgba[0] = 1;
         rgba[1] = 1 - 5 * (v - vmin - 0.6 * dv) / dv;
         rgba[2] = 0;
      } else {
         rgba[0] = 1;
         rgba[1] = 5 * (v - vmin - 0.8 * dv) / dv;
         rgba[2] = 5 * (v - vmin - 0.8 * dv) / dv;
      }
      break;
   case 11:
      c1[0] = 200 / 255.0; c1[1] =  60 / 255.0; c1[2] =   0 / 255.0;
      c2[0] = 250 / 255.0; c2[1] = 160 / 255.0; c2[2] = 110 / 255.0;
      rgba[0] = (c2[0] - c1[0]) * (v - vmin) / dv + c1[0];
      rgba[1] = (c2[1] - c1[1]) * (v - vmin) / dv + c1[1];
      rgba[2] = (c2[2] - c1[2]) * (v - vmin) / dv + c1[2];
      break;
   case 12:
      c1[0] =  55 / 255.0; c1[1] =  55 / 255.0; c1[2] =  45 / 255.0;
      c2[0] = 200 / 255.0; c2[1] =  60 / 255.0; c2[2] =   0 / 255.0;
      c3[0] = 250 / 255.0; c3[1] = 160 / 255.0; c3[2] = 110 / 255.0;
      ratio = 0.4;
      vmid = vmin + ratio * dv;
      if (v < vmid) {
         rgba[0] = (c2[0] - c1[0]) * (v - vmin) / (ratio*dv) + c1[0];
         rgba[1] = (c2[1] - c1[1]) * (v - vmin) / (ratio*dv) + c1[1];
         rgba[2] = (c2[2] - c1[2]) * (v - vmin) / (ratio*dv) + c1[2];
      } else {
         rgba[0] = (c3[0] - c2[0]) * (v - vmid) / ((1-ratio)*dv) + c2[0];
         rgba[1] = (c3[1] - c2[1]) * (v - vmid) / ((1-ratio)*dv) + c2[1];
         rgba[2] = (c3[2] - c2[2]) * (v - vmid) / ((1-ratio)*dv) + c2[2];
      }
      break;
   case 13:
      c1[0] =   0 / 255.0; c1[1] = 255 / 255.0; c1[2] =   0 / 255.0;
      c2[0] = 255 / 255.0; c2[1] = 150 / 255.0; c2[2] =   0 / 255.0;
      c3[0] = 255 / 255.0; c3[1] = 250 / 255.0; c3[2] = 240 / 255.0;
      ratio = 0.3;
      vmid = vmin + ratio * dv;
      if (v < vmid) {
         rgba[0] = (c2[0] - c1[0]) * (v - vmin) / (ratio*dv) + c1[0];
         rgba[1] = (c2[1] - c1[1]) * (v - vmin) / (ratio*dv) + c1[1];
         rgba[2] = (c2[2] - c1[2]) * (v - vmin) / (ratio*dv) + c1[2];
      } else {
         rgba[0] = (c3[0] - c2[0]) * (v - vmid) / ((1-ratio)*dv) + c2[0];
         rgba[1] = (c3[1] - c2[1]) * (v - vmid) / ((1-ratio)*dv) + c2[1];
         rgba[2] = (c3[2] - c2[2]) * (v - vmid) / ((1-ratio)*dv) + c2[2];
      }
      break;
   case 14:
      rgba[0] = 1;
      rgba[1] = 1 - (v - vmin) / dv;
      rgba[2] = 0;
      break;
   case 15:
      if (v < (vmin + 0.25 * dv)) {
         rgba[0] = 0;
         rgba[1] = 4 * (v - vmin) / dv;
         rgba[2] = 1;
      } else if (v < (vmin + 0.5 * dv)) {
         rgba[0] = 0;
         rgba[1] = 1;
         rgba[2] = 1 - 4 * (v - vmin - 0.25 * dv) / dv;
      } else if (v < (vmin + 0.75 * dv)) {
         rgba[0] = 4 * (v - vmin - 0.5 * dv) / dv;
         rgba[1] = 1;
         rgba[2] = 0;
      } else {
         rgba[0] = 1;
         rgba[1] = 1;
         rgba[2] = 4 * (v - vmin - 0.75 * dv) / dv;
      }
      break;
   case 16:
      if (v < (vmin + 0.5 * dv)) {
         rgba[0] = 0.0;
         rgba[1] = 2 * (v - vmin) / dv;
         rgba[2] = 1 - 2 * (v - vmin) / dv;
      } else {
         rgba[0] = 2 * (v - vmin - 0.5 * dv) / dv;
         rgba[1] = 1 - 2 * (v - vmin - 0.5 * dv) / dv;
         rgba[2] = 0.0;
      }
      break;
   case 17:
      if (v < (vmin + 0.5 * dv)) {
         rgba[0] = 1.0;
         rgba[1] = 1 - 2 * (v - vmin) / dv;
         rgba[2] = 2 * (v - vmin) / dv;
      } else {
         rgba[0] = 1 - 2 * (v - vmin - 0.5 * dv) / dv;
         rgba[1] = 2 * (v - vmin - 0.5 * dv) / dv;
         rgba[2] = 1.0;
      }
      break;
   case 18:
      rgba[0] = 0;
      rgba[1] = (v - vmin) / (vmax - vmin);
      rgba[2] = 1;
      break;
   case 19:
      rgba[0] = (v - vmin) / (vmax - vmin);
      rgba[1] = rgba[0];
      rgba[2] = 1;
      break;
   case 20:
      c1[0] =   0 / 255.0; c1[1] = 160 / 255.0; c1[2] =   0 / 255.0;
      c2[0] = 180 / 255.0; c2[1] = 220 / 255.0; c2[2] =   0 / 255.0;
      c3[0] = 250 / 255.0; c3[1] = 220 / 255.0; c3[2] = 170 / 255.0;
      ratio = 0.3;
      vmid = vmin + ratio * dv;
      if (v < vmid) {
         rgba[0] = (c2[0] - c1[0]) * (v - vmin) / (ratio*dv) + c1[0];
         rgba[1] = (c2[1] - c1[1]) * (v - vmin) / (ratio*dv) + c1[1];
         rgba[2] = (c2[2] - c1[2]) * (v - vmin) / (ratio*dv) + c1[2];
      } else {
         rgba[0] = (c3[0] - c2[0]) * (v - vmid) / ((1-ratio)*dv) + c2[0];
         rgba[1] = (c3[1] - c2[1]) * (v - vmid) / ((1-ratio)*dv) + c2[1];
         rgba[2] = (c3[2] - c2[2]) * (v - vmid) / ((1-ratio)*dv) + c2[2];
      }
      break;
   }
}

}

//______________________________________________________________________________
TGLLevelPalette::TGLLevelPalette()
                  : fContours(0),
                    fPaletteSize(0),
                    fTexture(0),
                    fMaxPaletteSize(0)
{
   //Ctor.
}

//______________________________________________________________________________
Bool_t TGLLevelPalette::GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t check)
{
   //Try to find colors for palette.
   if (!fMaxPaletteSize && check)
      glGetIntegerv(GL_MAX_TEXTURE_SIZE, &fMaxPaletteSize);

   if (!(zRange.second - zRange.first))
      return kFALSE;

   if (!paletteSize) {
       Error("TGLLevelPaletter::GeneratePalette",
             "Invalid palette size, must be a positive number");
       return kFALSE;
   }

   if (check && paletteSize > UInt_t(fMaxPaletteSize)) {
      Error("TGLLevelPalette::GeneratePalette",
            "Number of contours %d is too big for GL 1D texture, try to reduce it to %d",
            paletteSize, fMaxPaletteSize);
      return kFALSE;
   }

   UInt_t nearestPow2 = 2;
   while (nearestPow2 < paletteSize)
      nearestPow2 <<= 1;

   fTexels.resize(4 * nearestPow2);
   fPaletteSize = paletteSize;

   //Generate texels.
   const Int_t nColors = gStyle->GetNumberOfColors();

   //Map color index into index in real palette.

   for (UInt_t i = 0; i < paletteSize; ++i) {
      Int_t paletteInd = Int_t(nColors / Double_t(paletteSize) * i);
      if (paletteInd > nColors - 1)
         paletteInd = nColors - 1;
      Int_t colorInd = gStyle->GetColorPalette(paletteInd);

      if (const TColor *c = gROOT->GetColor(colorInd)) {
         Float_t rgb[3] = {};
         c->GetRGB(rgb[0], rgb[1], rgb[2]);
         fTexels[i * 4]     = UChar_t(rgb[0] * 255);
         fTexels[i * 4 + 1] = UChar_t(rgb[1] * 255);
         fTexels[i * 4 + 2] = UChar_t(rgb[2] * 255);
         fTexels[i * 4 + 3] = 200;//alpha
      }
   }

   fZRange = zRange;

   return kTRUE;
}

//______________________________________________________________________________
void TGLLevelPalette::SetContours(const std::vector<Double_t> *cont)
{
   //Clear :)
   fContours = cont;
}

//______________________________________________________________________________
void TGLLevelPalette::EnableTexture(Int_t mode)const
{
   //Enable 1D texture
   glEnable(GL_TEXTURE_1D);

   glGenTextures(1, &fTexture);

   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   glBindTexture(GL_TEXTURE_1D, fTexture);
   glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, fTexels.size() / 4, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, &fTexels[0]);
   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GLint(mode));
}

//______________________________________________________________________________
void TGLLevelPalette::DisableTexture()const
{
   //Disable 1D texture
   glDeleteTextures(1, &fTexture);
   glDisable(GL_TEXTURE_1D);
}

//______________________________________________________________________________
Int_t TGLLevelPalette::GetPaletteSize()const
{
   //Get. Palette. Size.
   return Int_t(fPaletteSize);
}

//______________________________________________________________________________
Double_t TGLLevelPalette::GetTexCoord(Double_t z)const
{
   //Get tex coordinate
   if (!fContours) {
      if (z - fZRange.first < 0)
         z = fZRange.first;
      else if (fZRange.second < z)
         z = fZRange.second;

      return (z - fZRange.first) / (fZRange.second - fZRange.first) * fPaletteSize / (fTexels.size() / 4);
   }
   /*
   //This part is wrong. To be fixed.
   std::vector<Double_t>::size_type i = 0, e = fContours->size();

   if (!e)
      return 0.;

   for (; i < e - 1; ++i) {
      if (z >= (*fContours)[i] && z <= (*fContours)[i + 1])
         return i / Double_t(fTexels.size() / 4);
   }
   */

   return 1.;
}

//______________________________________________________________________________
const UChar_t *TGLLevelPalette::GetColour(Double_t z)const
{
   //Get color.
   if (z - fZRange.first < 0)
      z = fZRange.first;
   else if (fZRange.second < z)
      z = fZRange.second;

   UInt_t ind = UInt_t((z - fZRange.first) / (fZRange.second - fZRange.first) * fPaletteSize);
   if (ind >= fPaletteSize)
      ind = fPaletteSize - 1;

   return &fTexels[ind * 4];
}

//______________________________________________________________________________
const UChar_t *TGLLevelPalette::GetColour(Int_t ind)const
{
   //Get color.
   return &fTexels[ind * 4];
}
 TGLUtil.cxx:1
 TGLUtil.cxx:2
 TGLUtil.cxx:3
 TGLUtil.cxx:4
 TGLUtil.cxx:5
 TGLUtil.cxx:6
 TGLUtil.cxx:7
 TGLUtil.cxx:8
 TGLUtil.cxx:9
 TGLUtil.cxx:10
 TGLUtil.cxx:11
 TGLUtil.cxx:12
 TGLUtil.cxx:13
 TGLUtil.cxx:14
 TGLUtil.cxx:15
 TGLUtil.cxx:16
 TGLUtil.cxx:17
 TGLUtil.cxx:18
 TGLUtil.cxx:19
 TGLUtil.cxx:20
 TGLUtil.cxx:21
 TGLUtil.cxx:22
 TGLUtil.cxx:23
 TGLUtil.cxx:24
 TGLUtil.cxx:25
 TGLUtil.cxx:26
 TGLUtil.cxx:27
 TGLUtil.cxx:28
 TGLUtil.cxx:29
 TGLUtil.cxx:30
 TGLUtil.cxx:31
 TGLUtil.cxx:32
 TGLUtil.cxx:33
 TGLUtil.cxx:34
 TGLUtil.cxx:35
 TGLUtil.cxx:36
 TGLUtil.cxx:37
 TGLUtil.cxx:38
 TGLUtil.cxx:39
 TGLUtil.cxx:40
 TGLUtil.cxx:41
 TGLUtil.cxx:42
 TGLUtil.cxx:43
 TGLUtil.cxx:44
 TGLUtil.cxx:45
 TGLUtil.cxx:46
 TGLUtil.cxx:47
 TGLUtil.cxx:48
 TGLUtil.cxx:49
 TGLUtil.cxx:50
 TGLUtil.cxx:51
 TGLUtil.cxx:52
 TGLUtil.cxx:53
 TGLUtil.cxx:54
 TGLUtil.cxx:55
 TGLUtil.cxx:56
 TGLUtil.cxx:57
 TGLUtil.cxx:58
 TGLUtil.cxx:59
 TGLUtil.cxx:60
 TGLUtil.cxx:61
 TGLUtil.cxx:62
 TGLUtil.cxx:63
 TGLUtil.cxx:64
 TGLUtil.cxx:65
 TGLUtil.cxx:66
 TGLUtil.cxx:67
 TGLUtil.cxx:68
 TGLUtil.cxx:69
 TGLUtil.cxx:70
 TGLUtil.cxx:71
 TGLUtil.cxx:72
 TGLUtil.cxx:73
 TGLUtil.cxx:74
 TGLUtil.cxx:75
 TGLUtil.cxx:76
 TGLUtil.cxx:77
 TGLUtil.cxx:78
 TGLUtil.cxx:79
 TGLUtil.cxx:80
 TGLUtil.cxx:81
 TGLUtil.cxx:82
 TGLUtil.cxx:83
 TGLUtil.cxx:84
 TGLUtil.cxx:85
 TGLUtil.cxx:86
 TGLUtil.cxx:87
 TGLUtil.cxx:88
 TGLUtil.cxx:89
 TGLUtil.cxx:90
 TGLUtil.cxx:91
 TGLUtil.cxx:92
 TGLUtil.cxx:93
 TGLUtil.cxx:94
 TGLUtil.cxx:95
 TGLUtil.cxx:96
 TGLUtil.cxx:97
 TGLUtil.cxx:98
 TGLUtil.cxx:99
 TGLUtil.cxx:100
 TGLUtil.cxx:101
 TGLUtil.cxx:102
 TGLUtil.cxx:103
 TGLUtil.cxx:104
 TGLUtil.cxx:105
 TGLUtil.cxx:106
 TGLUtil.cxx:107
 TGLUtil.cxx:108
 TGLUtil.cxx:109
 TGLUtil.cxx:110
 TGLUtil.cxx:111
 TGLUtil.cxx:112
 TGLUtil.cxx:113
 TGLUtil.cxx:114
 TGLUtil.cxx:115
 TGLUtil.cxx:116
 TGLUtil.cxx:117
 TGLUtil.cxx:118
 TGLUtil.cxx:119
 TGLUtil.cxx:120
 TGLUtil.cxx:121
 TGLUtil.cxx:122
 TGLUtil.cxx:123
 TGLUtil.cxx:124
 TGLUtil.cxx:125
 TGLUtil.cxx:126
 TGLUtil.cxx:127
 TGLUtil.cxx:128
 TGLUtil.cxx:129
 TGLUtil.cxx:130
 TGLUtil.cxx:131
 TGLUtil.cxx:132
 TGLUtil.cxx:133
 TGLUtil.cxx:134
 TGLUtil.cxx:135
 TGLUtil.cxx:136
 TGLUtil.cxx:137
 TGLUtil.cxx:138
 TGLUtil.cxx:139
 TGLUtil.cxx:140
 TGLUtil.cxx:141
 TGLUtil.cxx:142
 TGLUtil.cxx:143
 TGLUtil.cxx:144
 TGLUtil.cxx:145
 TGLUtil.cxx:146
 TGLUtil.cxx:147
 TGLUtil.cxx:148
 TGLUtil.cxx:149
 TGLUtil.cxx:150
 TGLUtil.cxx:151
 TGLUtil.cxx:152
 TGLUtil.cxx:153
 TGLUtil.cxx:154
 TGLUtil.cxx:155
 TGLUtil.cxx:156
 TGLUtil.cxx:157
 TGLUtil.cxx:158
 TGLUtil.cxx:159
 TGLUtil.cxx:160
 TGLUtil.cxx:161
 TGLUtil.cxx:162
 TGLUtil.cxx:163
 TGLUtil.cxx:164
 TGLUtil.cxx:165
 TGLUtil.cxx:166
 TGLUtil.cxx:167
 TGLUtil.cxx:168
 TGLUtil.cxx:169
 TGLUtil.cxx:170
 TGLUtil.cxx:171
 TGLUtil.cxx:172
 TGLUtil.cxx:173
 TGLUtil.cxx:174
 TGLUtil.cxx:175
 TGLUtil.cxx:176
 TGLUtil.cxx:177
 TGLUtil.cxx:178
 TGLUtil.cxx:179
 TGLUtil.cxx:180
 TGLUtil.cxx:181
 TGLUtil.cxx:182
 TGLUtil.cxx:183
 TGLUtil.cxx:184
 TGLUtil.cxx:185
 TGLUtil.cxx:186
 TGLUtil.cxx:187
 TGLUtil.cxx:188
 TGLUtil.cxx:189
 TGLUtil.cxx:190
 TGLUtil.cxx:191
 TGLUtil.cxx:192
 TGLUtil.cxx:193
 TGLUtil.cxx:194
 TGLUtil.cxx:195
 TGLUtil.cxx:196
 TGLUtil.cxx:197
 TGLUtil.cxx:198
 TGLUtil.cxx:199
 TGLUtil.cxx:200
 TGLUtil.cxx:201
 TGLUtil.cxx:202
 TGLUtil.cxx:203
 TGLUtil.cxx:204
 TGLUtil.cxx:205
 TGLUtil.cxx:206
 TGLUtil.cxx:207
 TGLUtil.cxx:208
 TGLUtil.cxx:209
 TGLUtil.cxx:210
 TGLUtil.cxx:211
 TGLUtil.cxx:212
 TGLUtil.cxx:213
 TGLUtil.cxx:214
 TGLUtil.cxx:215
 TGLUtil.cxx:216
 TGLUtil.cxx:217
 TGLUtil.cxx:218
 TGLUtil.cxx:219
 TGLUtil.cxx:220
 TGLUtil.cxx:221
 TGLUtil.cxx:222
 TGLUtil.cxx:223
 TGLUtil.cxx:224
 TGLUtil.cxx:225
 TGLUtil.cxx:226
 TGLUtil.cxx:227
 TGLUtil.cxx:228
 TGLUtil.cxx:229
 TGLUtil.cxx:230
 TGLUtil.cxx:231
 TGLUtil.cxx:232
 TGLUtil.cxx:233
 TGLUtil.cxx:234
 TGLUtil.cxx:235
 TGLUtil.cxx:236
 TGLUtil.cxx:237
 TGLUtil.cxx:238
 TGLUtil.cxx:239
 TGLUtil.cxx:240
 TGLUtil.cxx:241
 TGLUtil.cxx:242
 TGLUtil.cxx:243
 TGLUtil.cxx:244
 TGLUtil.cxx:245
 TGLUtil.cxx:246
 TGLUtil.cxx:247
 TGLUtil.cxx:248
 TGLUtil.cxx:249
 TGLUtil.cxx:250
 TGLUtil.cxx:251
 TGLUtil.cxx:252
 TGLUtil.cxx:253
 TGLUtil.cxx:254
 TGLUtil.cxx:255
 TGLUtil.cxx:256
 TGLUtil.cxx:257
 TGLUtil.cxx:258
 TGLUtil.cxx:259
 TGLUtil.cxx:260
 TGLUtil.cxx:261
 TGLUtil.cxx:262
 TGLUtil.cxx:263
 TGLUtil.cxx:264
 TGLUtil.cxx:265
 TGLUtil.cxx:266
 TGLUtil.cxx:267
 TGLUtil.cxx:268
 TGLUtil.cxx:269
 TGLUtil.cxx:270
 TGLUtil.cxx:271
 TGLUtil.cxx:272
 TGLUtil.cxx:273
 TGLUtil.cxx:274
 TGLUtil.cxx:275
 TGLUtil.cxx:276
 TGLUtil.cxx:277
 TGLUtil.cxx:278
 TGLUtil.cxx:279
 TGLUtil.cxx:280
 TGLUtil.cxx:281
 TGLUtil.cxx:282
 TGLUtil.cxx:283
 TGLUtil.cxx:284
 TGLUtil.cxx:285
 TGLUtil.cxx:286
 TGLUtil.cxx:287
 TGLUtil.cxx:288
 TGLUtil.cxx:289
 TGLUtil.cxx:290
 TGLUtil.cxx:291
 TGLUtil.cxx:292
 TGLUtil.cxx:293
 TGLUtil.cxx:294
 TGLUtil.cxx:295
 TGLUtil.cxx:296
 TGLUtil.cxx:297
 TGLUtil.cxx:298
 TGLUtil.cxx:299
 TGLUtil.cxx:300
 TGLUtil.cxx:301
 TGLUtil.cxx:302
 TGLUtil.cxx:303
 TGLUtil.cxx:304
 TGLUtil.cxx:305
 TGLUtil.cxx:306
 TGLUtil.cxx:307
 TGLUtil.cxx:308
 TGLUtil.cxx:309
 TGLUtil.cxx:310
 TGLUtil.cxx:311
 TGLUtil.cxx:312
 TGLUtil.cxx:313
 TGLUtil.cxx:314
 TGLUtil.cxx:315
 TGLUtil.cxx:316
 TGLUtil.cxx:317
 TGLUtil.cxx:318
 TGLUtil.cxx:319
 TGLUtil.cxx:320
 TGLUtil.cxx:321
 TGLUtil.cxx:322
 TGLUtil.cxx:323
 TGLUtil.cxx:324
 TGLUtil.cxx:325
 TGLUtil.cxx:326
 TGLUtil.cxx:327
 TGLUtil.cxx:328
 TGLUtil.cxx:329
 TGLUtil.cxx:330
 TGLUtil.cxx:331
 TGLUtil.cxx:332
 TGLUtil.cxx:333
 TGLUtil.cxx:334
 TGLUtil.cxx:335
 TGLUtil.cxx:336
 TGLUtil.cxx:337
 TGLUtil.cxx:338
 TGLUtil.cxx:339
 TGLUtil.cxx:340
 TGLUtil.cxx:341
 TGLUtil.cxx:342
 TGLUtil.cxx:343
 TGLUtil.cxx:344
 TGLUtil.cxx:345
 TGLUtil.cxx:346
 TGLUtil.cxx:347
 TGLUtil.cxx:348
 TGLUtil.cxx:349
 TGLUtil.cxx:350
 TGLUtil.cxx:351
 TGLUtil.cxx:352
 TGLUtil.cxx:353
 TGLUtil.cxx:354
 TGLUtil.cxx:355
 TGLUtil.cxx:356
 TGLUtil.cxx:357
 TGLUtil.cxx:358
 TGLUtil.cxx:359
 TGLUtil.cxx:360
 TGLUtil.cxx:361
 TGLUtil.cxx:362
 TGLUtil.cxx:363
 TGLUtil.cxx:364
 TGLUtil.cxx:365
 TGLUtil.cxx:366
 TGLUtil.cxx:367
 TGLUtil.cxx:368
 TGLUtil.cxx:369
 TGLUtil.cxx:370
 TGLUtil.cxx:371
 TGLUtil.cxx:372
 TGLUtil.cxx:373
 TGLUtil.cxx:374
 TGLUtil.cxx:375
 TGLUtil.cxx:376
 TGLUtil.cxx:377
 TGLUtil.cxx:378
 TGLUtil.cxx:379
 TGLUtil.cxx:380
 TGLUtil.cxx:381
 TGLUtil.cxx:382
 TGLUtil.cxx:383
 TGLUtil.cxx:384
 TGLUtil.cxx:385
 TGLUtil.cxx:386
 TGLUtil.cxx:387
 TGLUtil.cxx:388
 TGLUtil.cxx:389
 TGLUtil.cxx:390
 TGLUtil.cxx:391
 TGLUtil.cxx:392
 TGLUtil.cxx:393
 TGLUtil.cxx:394
 TGLUtil.cxx:395
 TGLUtil.cxx:396
 TGLUtil.cxx:397
 TGLUtil.cxx:398
 TGLUtil.cxx:399
 TGLUtil.cxx:400
 TGLUtil.cxx:401
 TGLUtil.cxx:402
 TGLUtil.cxx:403
 TGLUtil.cxx:404
 TGLUtil.cxx:405
 TGLUtil.cxx:406
 TGLUtil.cxx:407
 TGLUtil.cxx:408
 TGLUtil.cxx:409
 TGLUtil.cxx:410
 TGLUtil.cxx:411
 TGLUtil.cxx:412
 TGLUtil.cxx:413
 TGLUtil.cxx:414
 TGLUtil.cxx:415
 TGLUtil.cxx:416
 TGLUtil.cxx:417
 TGLUtil.cxx:418
 TGLUtil.cxx:419
 TGLUtil.cxx:420
 TGLUtil.cxx:421
 TGLUtil.cxx:422
 TGLUtil.cxx:423
 TGLUtil.cxx:424
 TGLUtil.cxx:425
 TGLUtil.cxx:426
 TGLUtil.cxx:427
 TGLUtil.cxx:428
 TGLUtil.cxx:429
 TGLUtil.cxx:430
 TGLUtil.cxx:431
 TGLUtil.cxx:432
 TGLUtil.cxx:433
 TGLUtil.cxx:434
 TGLUtil.cxx:435
 TGLUtil.cxx:436
 TGLUtil.cxx:437
 TGLUtil.cxx:438
 TGLUtil.cxx:439
 TGLUtil.cxx:440
 TGLUtil.cxx:441
 TGLUtil.cxx:442
 TGLUtil.cxx:443
 TGLUtil.cxx:444
 TGLUtil.cxx:445
 TGLUtil.cxx:446
 TGLUtil.cxx:447
 TGLUtil.cxx:448
 TGLUtil.cxx:449
 TGLUtil.cxx:450
 TGLUtil.cxx:451
 TGLUtil.cxx:452
 TGLUtil.cxx:453
 TGLUtil.cxx:454
 TGLUtil.cxx:455
 TGLUtil.cxx:456
 TGLUtil.cxx:457
 TGLUtil.cxx:458
 TGLUtil.cxx:459
 TGLUtil.cxx:460
 TGLUtil.cxx:461
 TGLUtil.cxx:462
 TGLUtil.cxx:463
 TGLUtil.cxx:464
 TGLUtil.cxx:465
 TGLUtil.cxx:466
 TGLUtil.cxx:467
 TGLUtil.cxx:468
 TGLUtil.cxx:469
 TGLUtil.cxx:470
 TGLUtil.cxx:471
 TGLUtil.cxx:472
 TGLUtil.cxx:473
 TGLUtil.cxx:474
 TGLUtil.cxx:475
 TGLUtil.cxx:476
 TGLUtil.cxx:477
 TGLUtil.cxx:478
 TGLUtil.cxx:479
 TGLUtil.cxx:480
 TGLUtil.cxx:481
 TGLUtil.cxx:482
 TGLUtil.cxx:483
 TGLUtil.cxx:484
 TGLUtil.cxx:485
 TGLUtil.cxx:486
 TGLUtil.cxx:487
 TGLUtil.cxx:488
 TGLUtil.cxx:489
 TGLUtil.cxx:490
 TGLUtil.cxx:491
 TGLUtil.cxx:492
 TGLUtil.cxx:493
 TGLUtil.cxx:494
 TGLUtil.cxx:495
 TGLUtil.cxx:496
 TGLUtil.cxx:497
 TGLUtil.cxx:498
 TGLUtil.cxx:499
 TGLUtil.cxx:500
 TGLUtil.cxx:501
 TGLUtil.cxx:502
 TGLUtil.cxx:503
 TGLUtil.cxx:504
 TGLUtil.cxx:505
 TGLUtil.cxx:506
 TGLUtil.cxx:507
 TGLUtil.cxx:508
 TGLUtil.cxx:509
 TGLUtil.cxx:510
 TGLUtil.cxx:511
 TGLUtil.cxx:512
 TGLUtil.cxx:513
 TGLUtil.cxx:514
 TGLUtil.cxx:515
 TGLUtil.cxx:516
 TGLUtil.cxx:517
 TGLUtil.cxx:518
 TGLUtil.cxx:519
 TGLUtil.cxx:520
 TGLUtil.cxx:521
 TGLUtil.cxx:522
 TGLUtil.cxx:523
 TGLUtil.cxx:524
 TGLUtil.cxx:525
 TGLUtil.cxx:526
 TGLUtil.cxx:527
 TGLUtil.cxx:528
 TGLUtil.cxx:529
 TGLUtil.cxx:530
 TGLUtil.cxx:531
 TGLUtil.cxx:532
 TGLUtil.cxx:533
 TGLUtil.cxx:534
 TGLUtil.cxx:535
 TGLUtil.cxx:536
 TGLUtil.cxx:537
 TGLUtil.cxx:538
 TGLUtil.cxx:539
 TGLUtil.cxx:540
 TGLUtil.cxx:541
 TGLUtil.cxx:542
 TGLUtil.cxx:543
 TGLUtil.cxx:544
 TGLUtil.cxx:545
 TGLUtil.cxx:546
 TGLUtil.cxx:547
 TGLUtil.cxx:548
 TGLUtil.cxx:549
 TGLUtil.cxx:550
 TGLUtil.cxx:551
 TGLUtil.cxx:552
 TGLUtil.cxx:553
 TGLUtil.cxx:554
 TGLUtil.cxx:555
 TGLUtil.cxx:556
 TGLUtil.cxx:557
 TGLUtil.cxx:558
 TGLUtil.cxx:559
 TGLUtil.cxx:560
 TGLUtil.cxx:561
 TGLUtil.cxx:562
 TGLUtil.cxx:563
 TGLUtil.cxx:564
 TGLUtil.cxx:565
 TGLUtil.cxx:566
 TGLUtil.cxx:567
 TGLUtil.cxx:568
 TGLUtil.cxx:569
 TGLUtil.cxx:570
 TGLUtil.cxx:571
 TGLUtil.cxx:572
 TGLUtil.cxx:573
 TGLUtil.cxx:574
 TGLUtil.cxx:575
 TGLUtil.cxx:576
 TGLUtil.cxx:577
 TGLUtil.cxx:578
 TGLUtil.cxx:579
 TGLUtil.cxx:580
 TGLUtil.cxx:581
 TGLUtil.cxx:582
 TGLUtil.cxx:583
 TGLUtil.cxx:584
 TGLUtil.cxx:585
 TGLUtil.cxx:586
 TGLUtil.cxx:587
 TGLUtil.cxx:588
 TGLUtil.cxx:589
 TGLUtil.cxx:590
 TGLUtil.cxx:591
 TGLUtil.cxx:592
 TGLUtil.cxx:593
 TGLUtil.cxx:594
 TGLUtil.cxx:595
 TGLUtil.cxx:596
 TGLUtil.cxx:597
 TGLUtil.cxx:598
 TGLUtil.cxx:599
 TGLUtil.cxx:600
 TGLUtil.cxx:601
 TGLUtil.cxx:602
 TGLUtil.cxx:603
 TGLUtil.cxx:604
 TGLUtil.cxx:605
 TGLUtil.cxx:606
 TGLUtil.cxx:607
 TGLUtil.cxx:608
 TGLUtil.cxx:609
 TGLUtil.cxx:610
 TGLUtil.cxx:611
 TGLUtil.cxx:612
 TGLUtil.cxx:613
 TGLUtil.cxx:614
 TGLUtil.cxx:615
 TGLUtil.cxx:616
 TGLUtil.cxx:617
 TGLUtil.cxx:618
 TGLUtil.cxx:619
 TGLUtil.cxx:620
 TGLUtil.cxx:621
 TGLUtil.cxx:622
 TGLUtil.cxx:623
 TGLUtil.cxx:624
 TGLUtil.cxx:625
 TGLUtil.cxx:626
 TGLUtil.cxx:627
 TGLUtil.cxx:628
 TGLUtil.cxx:629
 TGLUtil.cxx:630
 TGLUtil.cxx:631
 TGLUtil.cxx:632
 TGLUtil.cxx:633
 TGLUtil.cxx:634
 TGLUtil.cxx:635
 TGLUtil.cxx:636
 TGLUtil.cxx:637
 TGLUtil.cxx:638
 TGLUtil.cxx:639
 TGLUtil.cxx:640
 TGLUtil.cxx:641
 TGLUtil.cxx:642
 TGLUtil.cxx:643
 TGLUtil.cxx:644
 TGLUtil.cxx:645
 TGLUtil.cxx:646
 TGLUtil.cxx:647
 TGLUtil.cxx:648
 TGLUtil.cxx:649
 TGLUtil.cxx:650
 TGLUtil.cxx:651
 TGLUtil.cxx:652
 TGLUtil.cxx:653
 TGLUtil.cxx:654
 TGLUtil.cxx:655
 TGLUtil.cxx:656
 TGLUtil.cxx:657
 TGLUtil.cxx:658
 TGLUtil.cxx:659
 TGLUtil.cxx:660
 TGLUtil.cxx:661
 TGLUtil.cxx:662
 TGLUtil.cxx:663
 TGLUtil.cxx:664
 TGLUtil.cxx:665
 TGLUtil.cxx:666
 TGLUtil.cxx:667
 TGLUtil.cxx:668
 TGLUtil.cxx:669
 TGLUtil.cxx:670
 TGLUtil.cxx:671
 TGLUtil.cxx:672
 TGLUtil.cxx:673
 TGLUtil.cxx:674
 TGLUtil.cxx:675
 TGLUtil.cxx:676
 TGLUtil.cxx:677
 TGLUtil.cxx:678
 TGLUtil.cxx:679
 TGLUtil.cxx:680
 TGLUtil.cxx:681
 TGLUtil.cxx:682
 TGLUtil.cxx:683
 TGLUtil.cxx:684
 TGLUtil.cxx:685
 TGLUtil.cxx:686
 TGLUtil.cxx:687
 TGLUtil.cxx:688
 TGLUtil.cxx:689
 TGLUtil.cxx:690
 TGLUtil.cxx:691
 TGLUtil.cxx:692
 TGLUtil.cxx:693
 TGLUtil.cxx:694
 TGLUtil.cxx:695
 TGLUtil.cxx:696
 TGLUtil.cxx:697
 TGLUtil.cxx:698
 TGLUtil.cxx:699
 TGLUtil.cxx:700
 TGLUtil.cxx:701
 TGLUtil.cxx:702
 TGLUtil.cxx:703
 TGLUtil.cxx:704
 TGLUtil.cxx:705
 TGLUtil.cxx:706
 TGLUtil.cxx:707
 TGLUtil.cxx:708
 TGLUtil.cxx:709
 TGLUtil.cxx:710
 TGLUtil.cxx:711
 TGLUtil.cxx:712
 TGLUtil.cxx:713
 TGLUtil.cxx:714
 TGLUtil.cxx:715
 TGLUtil.cxx:716
 TGLUtil.cxx:717
 TGLUtil.cxx:718
 TGLUtil.cxx:719
 TGLUtil.cxx:720
 TGLUtil.cxx:721
 TGLUtil.cxx:722
 TGLUtil.cxx:723
 TGLUtil.cxx:724
 TGLUtil.cxx:725
 TGLUtil.cxx:726
 TGLUtil.cxx:727
 TGLUtil.cxx:728
 TGLUtil.cxx:729
 TGLUtil.cxx:730
 TGLUtil.cxx:731
 TGLUtil.cxx:732
 TGLUtil.cxx:733
 TGLUtil.cxx:734
 TGLUtil.cxx:735
 TGLUtil.cxx:736
 TGLUtil.cxx:737
 TGLUtil.cxx:738
 TGLUtil.cxx:739
 TGLUtil.cxx:740
 TGLUtil.cxx:741
 TGLUtil.cxx:742
 TGLUtil.cxx:743
 TGLUtil.cxx:744
 TGLUtil.cxx:745
 TGLUtil.cxx:746
 TGLUtil.cxx:747
 TGLUtil.cxx:748
 TGLUtil.cxx:749
 TGLUtil.cxx:750
 TGLUtil.cxx:751
 TGLUtil.cxx:752
 TGLUtil.cxx:753
 TGLUtil.cxx:754
 TGLUtil.cxx:755
 TGLUtil.cxx:756
 TGLUtil.cxx:757
 TGLUtil.cxx:758
 TGLUtil.cxx:759
 TGLUtil.cxx:760
 TGLUtil.cxx:761
 TGLUtil.cxx:762
 TGLUtil.cxx:763
 TGLUtil.cxx:764
 TGLUtil.cxx:765
 TGLUtil.cxx:766
 TGLUtil.cxx:767
 TGLUtil.cxx:768
 TGLUtil.cxx:769
 TGLUtil.cxx:770
 TGLUtil.cxx:771
 TGLUtil.cxx:772
 TGLUtil.cxx:773
 TGLUtil.cxx:774
 TGLUtil.cxx:775
 TGLUtil.cxx:776
 TGLUtil.cxx:777
 TGLUtil.cxx:778
 TGLUtil.cxx:779
 TGLUtil.cxx:780
 TGLUtil.cxx:781
 TGLUtil.cxx:782
 TGLUtil.cxx:783
 TGLUtil.cxx:784
 TGLUtil.cxx:785
 TGLUtil.cxx:786
 TGLUtil.cxx:787
 TGLUtil.cxx:788
 TGLUtil.cxx:789
 TGLUtil.cxx:790
 TGLUtil.cxx:791
 TGLUtil.cxx:792
 TGLUtil.cxx:793
 TGLUtil.cxx:794
 TGLUtil.cxx:795
 TGLUtil.cxx:796
 TGLUtil.cxx:797
 TGLUtil.cxx:798
 TGLUtil.cxx:799
 TGLUtil.cxx:800
 TGLUtil.cxx:801
 TGLUtil.cxx:802
 TGLUtil.cxx:803
 TGLUtil.cxx:804
 TGLUtil.cxx:805
 TGLUtil.cxx:806
 TGLUtil.cxx:807
 TGLUtil.cxx:808
 TGLUtil.cxx:809
 TGLUtil.cxx:810
 TGLUtil.cxx:811
 TGLUtil.cxx:812
 TGLUtil.cxx:813
 TGLUtil.cxx:814
 TGLUtil.cxx:815
 TGLUtil.cxx:816
 TGLUtil.cxx:817
 TGLUtil.cxx:818
 TGLUtil.cxx:819
 TGLUtil.cxx:820
 TGLUtil.cxx:821
 TGLUtil.cxx:822
 TGLUtil.cxx:823
 TGLUtil.cxx:824
 TGLUtil.cxx:825
 TGLUtil.cxx:826
 TGLUtil.cxx:827
 TGLUtil.cxx:828
 TGLUtil.cxx:829
 TGLUtil.cxx:830
 TGLUtil.cxx:831
 TGLUtil.cxx:832
 TGLUtil.cxx:833
 TGLUtil.cxx:834
 TGLUtil.cxx:835
 TGLUtil.cxx:836
 TGLUtil.cxx:837
 TGLUtil.cxx:838
 TGLUtil.cxx:839
 TGLUtil.cxx:840
 TGLUtil.cxx:841
 TGLUtil.cxx:842
 TGLUtil.cxx:843
 TGLUtil.cxx:844
 TGLUtil.cxx:845
 TGLUtil.cxx:846
 TGLUtil.cxx:847
 TGLUtil.cxx:848
 TGLUtil.cxx:849
 TGLUtil.cxx:850
 TGLUtil.cxx:851
 TGLUtil.cxx:852
 TGLUtil.cxx:853
 TGLUtil.cxx:854
 TGLUtil.cxx:855
 TGLUtil.cxx:856
 TGLUtil.cxx:857
 TGLUtil.cxx:858
 TGLUtil.cxx:859
 TGLUtil.cxx:860
 TGLUtil.cxx:861
 TGLUtil.cxx:862
 TGLUtil.cxx:863
 TGLUtil.cxx:864
 TGLUtil.cxx:865
 TGLUtil.cxx:866
 TGLUtil.cxx:867
 TGLUtil.cxx:868
 TGLUtil.cxx:869
 TGLUtil.cxx:870
 TGLUtil.cxx:871
 TGLUtil.cxx:872
 TGLUtil.cxx:873
 TGLUtil.cxx:874
 TGLUtil.cxx:875
 TGLUtil.cxx:876
 TGLUtil.cxx:877
 TGLUtil.cxx:878
 TGLUtil.cxx:879
 TGLUtil.cxx:880
 TGLUtil.cxx:881
 TGLUtil.cxx:882
 TGLUtil.cxx:883
 TGLUtil.cxx:884
 TGLUtil.cxx:885
 TGLUtil.cxx:886
 TGLUtil.cxx:887
 TGLUtil.cxx:888
 TGLUtil.cxx:889
 TGLUtil.cxx:890
 TGLUtil.cxx:891
 TGLUtil.cxx:892
 TGLUtil.cxx:893
 TGLUtil.cxx:894
 TGLUtil.cxx:895
 TGLUtil.cxx:896
 TGLUtil.cxx:897
 TGLUtil.cxx:898
 TGLUtil.cxx:899
 TGLUtil.cxx:900
 TGLUtil.cxx:901
 TGLUtil.cxx:902
 TGLUtil.cxx:903
 TGLUtil.cxx:904
 TGLUtil.cxx:905
 TGLUtil.cxx:906
 TGLUtil.cxx:907
 TGLUtil.cxx:908
 TGLUtil.cxx:909
 TGLUtil.cxx:910
 TGLUtil.cxx:911
 TGLUtil.cxx:912
 TGLUtil.cxx:913
 TGLUtil.cxx:914
 TGLUtil.cxx:915
 TGLUtil.cxx:916
 TGLUtil.cxx:917
 TGLUtil.cxx:918
 TGLUtil.cxx:919
 TGLUtil.cxx:920
 TGLUtil.cxx:921
 TGLUtil.cxx:922
 TGLUtil.cxx:923
 TGLUtil.cxx:924
 TGLUtil.cxx:925
 TGLUtil.cxx:926
 TGLUtil.cxx:927
 TGLUtil.cxx:928
 TGLUtil.cxx:929
 TGLUtil.cxx:930
 TGLUtil.cxx:931
 TGLUtil.cxx:932
 TGLUtil.cxx:933
 TGLUtil.cxx:934
 TGLUtil.cxx:935
 TGLUtil.cxx:936
 TGLUtil.cxx:937
 TGLUtil.cxx:938
 TGLUtil.cxx:939
 TGLUtil.cxx:940
 TGLUtil.cxx:941
 TGLUtil.cxx:942
 TGLUtil.cxx:943
 TGLUtil.cxx:944
 TGLUtil.cxx:945
 TGLUtil.cxx:946
 TGLUtil.cxx:947
 TGLUtil.cxx:948
 TGLUtil.cxx:949
 TGLUtil.cxx:950
 TGLUtil.cxx:951
 TGLUtil.cxx:952
 TGLUtil.cxx:953
 TGLUtil.cxx:954
 TGLUtil.cxx:955
 TGLUtil.cxx:956
 TGLUtil.cxx:957
 TGLUtil.cxx:958
 TGLUtil.cxx:959
 TGLUtil.cxx:960
 TGLUtil.cxx:961
 TGLUtil.cxx:962
 TGLUtil.cxx:963
 TGLUtil.cxx:964
 TGLUtil.cxx:965
 TGLUtil.cxx:966
 TGLUtil.cxx:967
 TGLUtil.cxx:968
 TGLUtil.cxx:969
 TGLUtil.cxx:970
 TGLUtil.cxx:971
 TGLUtil.cxx:972
 TGLUtil.cxx:973
 TGLUtil.cxx:974
 TGLUtil.cxx:975
 TGLUtil.cxx:976
 TGLUtil.cxx:977
 TGLUtil.cxx:978
 TGLUtil.cxx:979
 TGLUtil.cxx:980
 TGLUtil.cxx:981
 TGLUtil.cxx:982
 TGLUtil.cxx:983
 TGLUtil.cxx:984
 TGLUtil.cxx:985
 TGLUtil.cxx:986
 TGLUtil.cxx:987
 TGLUtil.cxx:988
 TGLUtil.cxx:989
 TGLUtil.cxx:990
 TGLUtil.cxx:991
 TGLUtil.cxx:992
 TGLUtil.cxx:993
 TGLUtil.cxx:994
 TGLUtil.cxx:995
 TGLUtil.cxx:996
 TGLUtil.cxx:997
 TGLUtil.cxx:998
 TGLUtil.cxx:999
 TGLUtil.cxx:1000
 TGLUtil.cxx:1001
 TGLUtil.cxx:1002
 TGLUtil.cxx:1003
 TGLUtil.cxx:1004
 TGLUtil.cxx:1005
 TGLUtil.cxx:1006
 TGLUtil.cxx:1007
 TGLUtil.cxx:1008
 TGLUtil.cxx:1009
 TGLUtil.cxx:1010
 TGLUtil.cxx:1011
 TGLUtil.cxx:1012
 TGLUtil.cxx:1013
 TGLUtil.cxx:1014
 TGLUtil.cxx:1015
 TGLUtil.cxx:1016
 TGLUtil.cxx:1017
 TGLUtil.cxx:1018
 TGLUtil.cxx:1019
 TGLUtil.cxx:1020
 TGLUtil.cxx:1021
 TGLUtil.cxx:1022
 TGLUtil.cxx:1023
 TGLUtil.cxx:1024
 TGLUtil.cxx:1025
 TGLUtil.cxx:1026
 TGLUtil.cxx:1027
 TGLUtil.cxx:1028
 TGLUtil.cxx:1029
 TGLUtil.cxx:1030
 TGLUtil.cxx:1031
 TGLUtil.cxx:1032
 TGLUtil.cxx:1033
 TGLUtil.cxx:1034
 TGLUtil.cxx:1035
 TGLUtil.cxx:1036
 TGLUtil.cxx:1037
 TGLUtil.cxx:1038
 TGLUtil.cxx:1039
 TGLUtil.cxx:1040
 TGLUtil.cxx:1041
 TGLUtil.cxx:1042
 TGLUtil.cxx:1043
 TGLUtil.cxx:1044
 TGLUtil.cxx:1045
 TGLUtil.cxx:1046
 TGLUtil.cxx:1047
 TGLUtil.cxx:1048
 TGLUtil.cxx:1049
 TGLUtil.cxx:1050
 TGLUtil.cxx:1051
 TGLUtil.cxx:1052
 TGLUtil.cxx:1053
 TGLUtil.cxx:1054
 TGLUtil.cxx:1055
 TGLUtil.cxx:1056
 TGLUtil.cxx:1057
 TGLUtil.cxx:1058
 TGLUtil.cxx:1059
 TGLUtil.cxx:1060
 TGLUtil.cxx:1061
 TGLUtil.cxx:1062
 TGLUtil.cxx:1063
 TGLUtil.cxx:1064
 TGLUtil.cxx:1065
 TGLUtil.cxx:1066
 TGLUtil.cxx:1067
 TGLUtil.cxx:1068
 TGLUtil.cxx:1069
 TGLUtil.cxx:1070
 TGLUtil.cxx:1071
 TGLUtil.cxx:1072
 TGLUtil.cxx:1073
 TGLUtil.cxx:1074
 TGLUtil.cxx:1075
 TGLUtil.cxx:1076
 TGLUtil.cxx:1077
 TGLUtil.cxx:1078
 TGLUtil.cxx:1079
 TGLUtil.cxx:1080
 TGLUtil.cxx:1081
 TGLUtil.cxx:1082
 TGLUtil.cxx:1083
 TGLUtil.cxx:1084
 TGLUtil.cxx:1085
 TGLUtil.cxx:1086
 TGLUtil.cxx:1087
 TGLUtil.cxx:1088
 TGLUtil.cxx:1089
 TGLUtil.cxx:1090
 TGLUtil.cxx:1091
 TGLUtil.cxx:1092
 TGLUtil.cxx:1093
 TGLUtil.cxx:1094
 TGLUtil.cxx:1095
 TGLUtil.cxx:1096
 TGLUtil.cxx:1097
 TGLUtil.cxx:1098
 TGLUtil.cxx:1099
 TGLUtil.cxx:1100
 TGLUtil.cxx:1101
 TGLUtil.cxx:1102
 TGLUtil.cxx:1103
 TGLUtil.cxx:1104
 TGLUtil.cxx:1105
 TGLUtil.cxx:1106
 TGLUtil.cxx:1107
 TGLUtil.cxx:1108
 TGLUtil.cxx:1109
 TGLUtil.cxx:1110
 TGLUtil.cxx:1111
 TGLUtil.cxx:1112
 TGLUtil.cxx:1113
 TGLUtil.cxx:1114
 TGLUtil.cxx:1115
 TGLUtil.cxx:1116
 TGLUtil.cxx:1117
 TGLUtil.cxx:1118
 TGLUtil.cxx:1119
 TGLUtil.cxx:1120
 TGLUtil.cxx:1121
 TGLUtil.cxx:1122
 TGLUtil.cxx:1123
 TGLUtil.cxx:1124
 TGLUtil.cxx:1125
 TGLUtil.cxx:1126
 TGLUtil.cxx:1127
 TGLUtil.cxx:1128
 TGLUtil.cxx:1129
 TGLUtil.cxx:1130
 TGLUtil.cxx:1131
 TGLUtil.cxx:1132
 TGLUtil.cxx:1133
 TGLUtil.cxx:1134
 TGLUtil.cxx:1135
 TGLUtil.cxx:1136
 TGLUtil.cxx:1137
 TGLUtil.cxx:1138
 TGLUtil.cxx:1139
 TGLUtil.cxx:1140
 TGLUtil.cxx:1141
 TGLUtil.cxx:1142
 TGLUtil.cxx:1143
 TGLUtil.cxx:1144
 TGLUtil.cxx:1145
 TGLUtil.cxx:1146
 TGLUtil.cxx:1147
 TGLUtil.cxx:1148
 TGLUtil.cxx:1149
 TGLUtil.cxx:1150
 TGLUtil.cxx:1151
 TGLUtil.cxx:1152
 TGLUtil.cxx:1153
 TGLUtil.cxx:1154
 TGLUtil.cxx:1155
 TGLUtil.cxx:1156
 TGLUtil.cxx:1157
 TGLUtil.cxx:1158
 TGLUtil.cxx:1159
 TGLUtil.cxx:1160
 TGLUtil.cxx:1161
 TGLUtil.cxx:1162
 TGLUtil.cxx:1163
 TGLUtil.cxx:1164
 TGLUtil.cxx:1165
 TGLUtil.cxx:1166
 TGLUtil.cxx:1167
 TGLUtil.cxx:1168
 TGLUtil.cxx:1169
 TGLUtil.cxx:1170
 TGLUtil.cxx:1171
 TGLUtil.cxx:1172
 TGLUtil.cxx:1173
 TGLUtil.cxx:1174
 TGLUtil.cxx:1175
 TGLUtil.cxx:1176
 TGLUtil.cxx:1177
 TGLUtil.cxx:1178
 TGLUtil.cxx:1179
 TGLUtil.cxx:1180
 TGLUtil.cxx:1181
 TGLUtil.cxx:1182
 TGLUtil.cxx:1183
 TGLUtil.cxx:1184
 TGLUtil.cxx:1185
 TGLUtil.cxx:1186
 TGLUtil.cxx:1187
 TGLUtil.cxx:1188
 TGLUtil.cxx:1189
 TGLUtil.cxx:1190
 TGLUtil.cxx:1191
 TGLUtil.cxx:1192
 TGLUtil.cxx:1193
 TGLUtil.cxx:1194
 TGLUtil.cxx:1195
 TGLUtil.cxx:1196
 TGLUtil.cxx:1197
 TGLUtil.cxx:1198
 TGLUtil.cxx:1199
 TGLUtil.cxx:1200
 TGLUtil.cxx:1201
 TGLUtil.cxx:1202
 TGLUtil.cxx:1203
 TGLUtil.cxx:1204
 TGLUtil.cxx:1205
 TGLUtil.cxx:1206
 TGLUtil.cxx:1207
 TGLUtil.cxx:1208
 TGLUtil.cxx:1209
 TGLUtil.cxx:1210
 TGLUtil.cxx:1211
 TGLUtil.cxx:1212
 TGLUtil.cxx:1213
 TGLUtil.cxx:1214
 TGLUtil.cxx:1215
 TGLUtil.cxx:1216
 TGLUtil.cxx:1217
 TGLUtil.cxx:1218
 TGLUtil.cxx:1219
 TGLUtil.cxx:1220
 TGLUtil.cxx:1221
 TGLUtil.cxx:1222
 TGLUtil.cxx:1223
 TGLUtil.cxx:1224
 TGLUtil.cxx:1225
 TGLUtil.cxx:1226
 TGLUtil.cxx:1227
 TGLUtil.cxx:1228
 TGLUtil.cxx:1229
 TGLUtil.cxx:1230
 TGLUtil.cxx:1231
 TGLUtil.cxx:1232
 TGLUtil.cxx:1233
 TGLUtil.cxx:1234
 TGLUtil.cxx:1235
 TGLUtil.cxx:1236
 TGLUtil.cxx:1237
 TGLUtil.cxx:1238
 TGLUtil.cxx:1239
 TGLUtil.cxx:1240
 TGLUtil.cxx:1241
 TGLUtil.cxx:1242
 TGLUtil.cxx:1243
 TGLUtil.cxx:1244
 TGLUtil.cxx:1245
 TGLUtil.cxx:1246
 TGLUtil.cxx:1247
 TGLUtil.cxx:1248
 TGLUtil.cxx:1249
 TGLUtil.cxx:1250
 TGLUtil.cxx:1251
 TGLUtil.cxx:1252
 TGLUtil.cxx:1253
 TGLUtil.cxx:1254
 TGLUtil.cxx:1255
 TGLUtil.cxx:1256
 TGLUtil.cxx:1257
 TGLUtil.cxx:1258
 TGLUtil.cxx:1259
 TGLUtil.cxx:1260
 TGLUtil.cxx:1261
 TGLUtil.cxx:1262
 TGLUtil.cxx:1263
 TGLUtil.cxx:1264
 TGLUtil.cxx:1265
 TGLUtil.cxx:1266
 TGLUtil.cxx:1267
 TGLUtil.cxx:1268
 TGLUtil.cxx:1269
 TGLUtil.cxx:1270
 TGLUtil.cxx:1271
 TGLUtil.cxx:1272
 TGLUtil.cxx:1273
 TGLUtil.cxx:1274
 TGLUtil.cxx:1275
 TGLUtil.cxx:1276
 TGLUtil.cxx:1277
 TGLUtil.cxx:1278
 TGLUtil.cxx:1279
 TGLUtil.cxx:1280
 TGLUtil.cxx:1281
 TGLUtil.cxx:1282
 TGLUtil.cxx:1283
 TGLUtil.cxx:1284
 TGLUtil.cxx:1285
 TGLUtil.cxx:1286
 TGLUtil.cxx:1287
 TGLUtil.cxx:1288
 TGLUtil.cxx:1289
 TGLUtil.cxx:1290
 TGLUtil.cxx:1291
 TGLUtil.cxx:1292
 TGLUtil.cxx:1293
 TGLUtil.cxx:1294
 TGLUtil.cxx:1295
 TGLUtil.cxx:1296
 TGLUtil.cxx:1297
 TGLUtil.cxx:1298
 TGLUtil.cxx:1299
 TGLUtil.cxx:1300
 TGLUtil.cxx:1301
 TGLUtil.cxx:1302
 TGLUtil.cxx:1303
 TGLUtil.cxx:1304
 TGLUtil.cxx:1305
 TGLUtil.cxx:1306
 TGLUtil.cxx:1307
 TGLUtil.cxx:1308
 TGLUtil.cxx:1309
 TGLUtil.cxx:1310
 TGLUtil.cxx:1311
 TGLUtil.cxx:1312
 TGLUtil.cxx:1313
 TGLUtil.cxx:1314
 TGLUtil.cxx:1315
 TGLUtil.cxx:1316
 TGLUtil.cxx:1317
 TGLUtil.cxx:1318
 TGLUtil.cxx:1319
 TGLUtil.cxx:1320
 TGLUtil.cxx:1321
 TGLUtil.cxx:1322
 TGLUtil.cxx:1323
 TGLUtil.cxx:1324
 TGLUtil.cxx:1325
 TGLUtil.cxx:1326
 TGLUtil.cxx:1327
 TGLUtil.cxx:1328
 TGLUtil.cxx:1329
 TGLUtil.cxx:1330
 TGLUtil.cxx:1331
 TGLUtil.cxx:1332
 TGLUtil.cxx:1333
 TGLUtil.cxx:1334
 TGLUtil.cxx:1335
 TGLUtil.cxx:1336
 TGLUtil.cxx:1337
 TGLUtil.cxx:1338
 TGLUtil.cxx:1339
 TGLUtil.cxx:1340
 TGLUtil.cxx:1341
 TGLUtil.cxx:1342
 TGLUtil.cxx:1343
 TGLUtil.cxx:1344
 TGLUtil.cxx:1345
 TGLUtil.cxx:1346
 TGLUtil.cxx:1347
 TGLUtil.cxx:1348
 TGLUtil.cxx:1349
 TGLUtil.cxx:1350
 TGLUtil.cxx:1351
 TGLUtil.cxx:1352
 TGLUtil.cxx:1353
 TGLUtil.cxx:1354
 TGLUtil.cxx:1355
 TGLUtil.cxx:1356
 TGLUtil.cxx:1357
 TGLUtil.cxx:1358
 TGLUtil.cxx:1359
 TGLUtil.cxx:1360
 TGLUtil.cxx:1361
 TGLUtil.cxx:1362
 TGLUtil.cxx:1363
 TGLUtil.cxx:1364
 TGLUtil.cxx:1365
 TGLUtil.cxx:1366
 TGLUtil.cxx:1367
 TGLUtil.cxx:1368
 TGLUtil.cxx:1369
 TGLUtil.cxx:1370
 TGLUtil.cxx:1371
 TGLUtil.cxx:1372
 TGLUtil.cxx:1373
 TGLUtil.cxx:1374
 TGLUtil.cxx:1375
 TGLUtil.cxx:1376
 TGLUtil.cxx:1377
 TGLUtil.cxx:1378
 TGLUtil.cxx:1379
 TGLUtil.cxx:1380
 TGLUtil.cxx:1381
 TGLUtil.cxx:1382
 TGLUtil.cxx:1383
 TGLUtil.cxx:1384
 TGLUtil.cxx:1385
 TGLUtil.cxx:1386
 TGLUtil.cxx:1387
 TGLUtil.cxx:1388
 TGLUtil.cxx:1389
 TGLUtil.cxx:1390
 TGLUtil.cxx:1391
 TGLUtil.cxx:1392
 TGLUtil.cxx:1393
 TGLUtil.cxx:1394
 TGLUtil.cxx:1395
 TGLUtil.cxx:1396
 TGLUtil.cxx:1397
 TGLUtil.cxx:1398
 TGLUtil.cxx:1399
 TGLUtil.cxx:1400
 TGLUtil.cxx:1401
 TGLUtil.cxx:1402
 TGLUtil.cxx:1403
 TGLUtil.cxx:1404
 TGLUtil.cxx:1405
 TGLUtil.cxx:1406
 TGLUtil.cxx:1407
 TGLUtil.cxx:1408
 TGLUtil.cxx:1409
 TGLUtil.cxx:1410
 TGLUtil.cxx:1411
 TGLUtil.cxx:1412
 TGLUtil.cxx:1413
 TGLUtil.cxx:1414
 TGLUtil.cxx:1415
 TGLUtil.cxx:1416
 TGLUtil.cxx:1417
 TGLUtil.cxx:1418
 TGLUtil.cxx:1419
 TGLUtil.cxx:1420
 TGLUtil.cxx:1421
 TGLUtil.cxx:1422
 TGLUtil.cxx:1423
 TGLUtil.cxx:1424
 TGLUtil.cxx:1425
 TGLUtil.cxx:1426
 TGLUtil.cxx:1427
 TGLUtil.cxx:1428
 TGLUtil.cxx:1429
 TGLUtil.cxx:1430
 TGLUtil.cxx:1431
 TGLUtil.cxx:1432
 TGLUtil.cxx:1433
 TGLUtil.cxx:1434
 TGLUtil.cxx:1435
 TGLUtil.cxx:1436
 TGLUtil.cxx:1437
 TGLUtil.cxx:1438
 TGLUtil.cxx:1439
 TGLUtil.cxx:1440
 TGLUtil.cxx:1441
 TGLUtil.cxx:1442
 TGLUtil.cxx:1443
 TGLUtil.cxx:1444
 TGLUtil.cxx:1445
 TGLUtil.cxx:1446
 TGLUtil.cxx:1447
 TGLUtil.cxx:1448
 TGLUtil.cxx:1449
 TGLUtil.cxx:1450
 TGLUtil.cxx:1451
 TGLUtil.cxx:1452
 TGLUtil.cxx:1453
 TGLUtil.cxx:1454
 TGLUtil.cxx:1455
 TGLUtil.cxx:1456
 TGLUtil.cxx:1457
 TGLUtil.cxx:1458
 TGLUtil.cxx:1459
 TGLUtil.cxx:1460
 TGLUtil.cxx:1461
 TGLUtil.cxx:1462
 TGLUtil.cxx:1463
 TGLUtil.cxx:1464
 TGLUtil.cxx:1465
 TGLUtil.cxx:1466
 TGLUtil.cxx:1467
 TGLUtil.cxx:1468
 TGLUtil.cxx:1469
 TGLUtil.cxx:1470
 TGLUtil.cxx:1471
 TGLUtil.cxx:1472
 TGLUtil.cxx:1473
 TGLUtil.cxx:1474
 TGLUtil.cxx:1475
 TGLUtil.cxx:1476
 TGLUtil.cxx:1477
 TGLUtil.cxx:1478
 TGLUtil.cxx:1479
 TGLUtil.cxx:1480
 TGLUtil.cxx:1481
 TGLUtil.cxx:1482
 TGLUtil.cxx:1483
 TGLUtil.cxx:1484
 TGLUtil.cxx:1485
 TGLUtil.cxx:1486
 TGLUtil.cxx:1487
 TGLUtil.cxx:1488
 TGLUtil.cxx:1489
 TGLUtil.cxx:1490
 TGLUtil.cxx:1491
 TGLUtil.cxx:1492
 TGLUtil.cxx:1493
 TGLUtil.cxx:1494
 TGLUtil.cxx:1495
 TGLUtil.cxx:1496
 TGLUtil.cxx:1497
 TGLUtil.cxx:1498
 TGLUtil.cxx:1499
 TGLUtil.cxx:1500
 TGLUtil.cxx:1501
 TGLUtil.cxx:1502
 TGLUtil.cxx:1503
 TGLUtil.cxx:1504
 TGLUtil.cxx:1505
 TGLUtil.cxx:1506
 TGLUtil.cxx:1507
 TGLUtil.cxx:1508
 TGLUtil.cxx:1509
 TGLUtil.cxx:1510
 TGLUtil.cxx:1511
 TGLUtil.cxx:1512
 TGLUtil.cxx:1513
 TGLUtil.cxx:1514
 TGLUtil.cxx:1515
 TGLUtil.cxx:1516
 TGLUtil.cxx:1517
 TGLUtil.cxx:1518
 TGLUtil.cxx:1519
 TGLUtil.cxx:1520
 TGLUtil.cxx:1521
 TGLUtil.cxx:1522
 TGLUtil.cxx:1523
 TGLUtil.cxx:1524
 TGLUtil.cxx:1525
 TGLUtil.cxx:1526
 TGLUtil.cxx:1527
 TGLUtil.cxx:1528
 TGLUtil.cxx:1529
 TGLUtil.cxx:1530
 TGLUtil.cxx:1531
 TGLUtil.cxx:1532
 TGLUtil.cxx:1533
 TGLUtil.cxx:1534
 TGLUtil.cxx:1535
 TGLUtil.cxx:1536
 TGLUtil.cxx:1537
 TGLUtil.cxx:1538
 TGLUtil.cxx:1539
 TGLUtil.cxx:1540
 TGLUtil.cxx:1541
 TGLUtil.cxx:1542
 TGLUtil.cxx:1543
 TGLUtil.cxx:1544
 TGLUtil.cxx:1545
 TGLUtil.cxx:1546
 TGLUtil.cxx:1547
 TGLUtil.cxx:1548
 TGLUtil.cxx:1549
 TGLUtil.cxx:1550
 TGLUtil.cxx:1551
 TGLUtil.cxx:1552
 TGLUtil.cxx:1553
 TGLUtil.cxx:1554
 TGLUtil.cxx:1555
 TGLUtil.cxx:1556
 TGLUtil.cxx:1557
 TGLUtil.cxx:1558
 TGLUtil.cxx:1559
 TGLUtil.cxx:1560
 TGLUtil.cxx:1561
 TGLUtil.cxx:1562
 TGLUtil.cxx:1563
 TGLUtil.cxx:1564
 TGLUtil.cxx:1565
 TGLUtil.cxx:1566
 TGLUtil.cxx:1567
 TGLUtil.cxx:1568
 TGLUtil.cxx:1569
 TGLUtil.cxx:1570
 TGLUtil.cxx:1571
 TGLUtil.cxx:1572
 TGLUtil.cxx:1573
 TGLUtil.cxx:1574
 TGLUtil.cxx:1575
 TGLUtil.cxx:1576
 TGLUtil.cxx:1577
 TGLUtil.cxx:1578
 TGLUtil.cxx:1579
 TGLUtil.cxx:1580
 TGLUtil.cxx:1581
 TGLUtil.cxx:1582
 TGLUtil.cxx:1583
 TGLUtil.cxx:1584
 TGLUtil.cxx:1585
 TGLUtil.cxx:1586
 TGLUtil.cxx:1587
 TGLUtil.cxx:1588
 TGLUtil.cxx:1589
 TGLUtil.cxx:1590
 TGLUtil.cxx:1591
 TGLUtil.cxx:1592
 TGLUtil.cxx:1593
 TGLUtil.cxx:1594
 TGLUtil.cxx:1595
 TGLUtil.cxx:1596
 TGLUtil.cxx:1597
 TGLUtil.cxx:1598
 TGLUtil.cxx:1599
 TGLUtil.cxx:1600
 TGLUtil.cxx:1601
 TGLUtil.cxx:1602
 TGLUtil.cxx:1603
 TGLUtil.cxx:1604
 TGLUtil.cxx:1605
 TGLUtil.cxx:1606
 TGLUtil.cxx:1607
 TGLUtil.cxx:1608
 TGLUtil.cxx:1609
 TGLUtil.cxx:1610
 TGLUtil.cxx:1611
 TGLUtil.cxx:1612
 TGLUtil.cxx:1613
 TGLUtil.cxx:1614
 TGLUtil.cxx:1615
 TGLUtil.cxx:1616
 TGLUtil.cxx:1617
 TGLUtil.cxx:1618
 TGLUtil.cxx:1619
 TGLUtil.cxx:1620
 TGLUtil.cxx:1621
 TGLUtil.cxx:1622
 TGLUtil.cxx:1623
 TGLUtil.cxx:1624
 TGLUtil.cxx:1625
 TGLUtil.cxx:1626
 TGLUtil.cxx:1627
 TGLUtil.cxx:1628
 TGLUtil.cxx:1629
 TGLUtil.cxx:1630
 TGLUtil.cxx:1631
 TGLUtil.cxx:1632
 TGLUtil.cxx:1633
 TGLUtil.cxx:1634
 TGLUtil.cxx:1635
 TGLUtil.cxx:1636
 TGLUtil.cxx:1637
 TGLUtil.cxx:1638
 TGLUtil.cxx:1639
 TGLUtil.cxx:1640
 TGLUtil.cxx:1641
 TGLUtil.cxx:1642
 TGLUtil.cxx:1643
 TGLUtil.cxx:1644
 TGLUtil.cxx:1645
 TGLUtil.cxx:1646
 TGLUtil.cxx:1647
 TGLUtil.cxx:1648
 TGLUtil.cxx:1649
 TGLUtil.cxx:1650
 TGLUtil.cxx:1651
 TGLUtil.cxx:1652
 TGLUtil.cxx:1653
 TGLUtil.cxx:1654
 TGLUtil.cxx:1655
 TGLUtil.cxx:1656
 TGLUtil.cxx:1657
 TGLUtil.cxx:1658
 TGLUtil.cxx:1659
 TGLUtil.cxx:1660
 TGLUtil.cxx:1661
 TGLUtil.cxx:1662
 TGLUtil.cxx:1663
 TGLUtil.cxx:1664
 TGLUtil.cxx:1665
 TGLUtil.cxx:1666
 TGLUtil.cxx:1667
 TGLUtil.cxx:1668
 TGLUtil.cxx:1669
 TGLUtil.cxx:1670
 TGLUtil.cxx:1671
 TGLUtil.cxx:1672
 TGLUtil.cxx:1673
 TGLUtil.cxx:1674
 TGLUtil.cxx:1675
 TGLUtil.cxx:1676
 TGLUtil.cxx:1677
 TGLUtil.cxx:1678
 TGLUtil.cxx:1679
 TGLUtil.cxx:1680
 TGLUtil.cxx:1681
 TGLUtil.cxx:1682
 TGLUtil.cxx:1683
 TGLUtil.cxx:1684
 TGLUtil.cxx:1685
 TGLUtil.cxx:1686
 TGLUtil.cxx:1687
 TGLUtil.cxx:1688
 TGLUtil.cxx:1689
 TGLUtil.cxx:1690
 TGLUtil.cxx:1691
 TGLUtil.cxx:1692
 TGLUtil.cxx:1693
 TGLUtil.cxx:1694
 TGLUtil.cxx:1695
 TGLUtil.cxx:1696
 TGLUtil.cxx:1697
 TGLUtil.cxx:1698
 TGLUtil.cxx:1699
 TGLUtil.cxx:1700
 TGLUtil.cxx:1701
 TGLUtil.cxx:1702
 TGLUtil.cxx:1703
 TGLUtil.cxx:1704
 TGLUtil.cxx:1705
 TGLUtil.cxx:1706
 TGLUtil.cxx:1707
 TGLUtil.cxx:1708
 TGLUtil.cxx:1709
 TGLUtil.cxx:1710
 TGLUtil.cxx:1711
 TGLUtil.cxx:1712
 TGLUtil.cxx:1713
 TGLUtil.cxx:1714
 TGLUtil.cxx:1715
 TGLUtil.cxx:1716
 TGLUtil.cxx:1717
 TGLUtil.cxx:1718
 TGLUtil.cxx:1719
 TGLUtil.cxx:1720
 TGLUtil.cxx:1721
 TGLUtil.cxx:1722
 TGLUtil.cxx:1723
 TGLUtil.cxx:1724
 TGLUtil.cxx:1725
 TGLUtil.cxx:1726
 TGLUtil.cxx:1727
 TGLUtil.cxx:1728
 TGLUtil.cxx:1729
 TGLUtil.cxx:1730
 TGLUtil.cxx:1731
 TGLUtil.cxx:1732
 TGLUtil.cxx:1733
 TGLUtil.cxx:1734
 TGLUtil.cxx:1735
 TGLUtil.cxx:1736
 TGLUtil.cxx:1737
 TGLUtil.cxx:1738
 TGLUtil.cxx:1739
 TGLUtil.cxx:1740
 TGLUtil.cxx:1741
 TGLUtil.cxx:1742
 TGLUtil.cxx:1743
 TGLUtil.cxx:1744
 TGLUtil.cxx:1745
 TGLUtil.cxx:1746
 TGLUtil.cxx:1747
 TGLUtil.cxx:1748
 TGLUtil.cxx:1749
 TGLUtil.cxx:1750
 TGLUtil.cxx:1751
 TGLUtil.cxx:1752
 TGLUtil.cxx:1753
 TGLUtil.cxx:1754
 TGLUtil.cxx:1755
 TGLUtil.cxx:1756
 TGLUtil.cxx:1757
 TGLUtil.cxx:1758
 TGLUtil.cxx:1759
 TGLUtil.cxx:1760
 TGLUtil.cxx:1761
 TGLUtil.cxx:1762
 TGLUtil.cxx:1763
 TGLUtil.cxx:1764
 TGLUtil.cxx:1765
 TGLUtil.cxx:1766
 TGLUtil.cxx:1767
 TGLUtil.cxx:1768
 TGLUtil.cxx:1769
 TGLUtil.cxx:1770
 TGLUtil.cxx:1771
 TGLUtil.cxx:1772
 TGLUtil.cxx:1773
 TGLUtil.cxx:1774
 TGLUtil.cxx:1775
 TGLUtil.cxx:1776
 TGLUtil.cxx:1777
 TGLUtil.cxx:1778
 TGLUtil.cxx:1779
 TGLUtil.cxx:1780
 TGLUtil.cxx:1781
 TGLUtil.cxx:1782
 TGLUtil.cxx:1783
 TGLUtil.cxx:1784
 TGLUtil.cxx:1785
 TGLUtil.cxx:1786
 TGLUtil.cxx:1787
 TGLUtil.cxx:1788
 TGLUtil.cxx:1789
 TGLUtil.cxx:1790
 TGLUtil.cxx:1791
 TGLUtil.cxx:1792
 TGLUtil.cxx:1793
 TGLUtil.cxx:1794
 TGLUtil.cxx:1795
 TGLUtil.cxx:1796
 TGLUtil.cxx:1797
 TGLUtil.cxx:1798
 TGLUtil.cxx:1799
 TGLUtil.cxx:1800
 TGLUtil.cxx:1801
 TGLUtil.cxx:1802
 TGLUtil.cxx:1803
 TGLUtil.cxx:1804
 TGLUtil.cxx:1805
 TGLUtil.cxx:1806
 TGLUtil.cxx:1807
 TGLUtil.cxx:1808
 TGLUtil.cxx:1809
 TGLUtil.cxx:1810
 TGLUtil.cxx:1811
 TGLUtil.cxx:1812
 TGLUtil.cxx:1813
 TGLUtil.cxx:1814
 TGLUtil.cxx:1815
 TGLUtil.cxx:1816
 TGLUtil.cxx:1817
 TGLUtil.cxx:1818
 TGLUtil.cxx:1819
 TGLUtil.cxx:1820
 TGLUtil.cxx:1821
 TGLUtil.cxx:1822
 TGLUtil.cxx:1823
 TGLUtil.cxx:1824
 TGLUtil.cxx:1825
 TGLUtil.cxx:1826
 TGLUtil.cxx:1827
 TGLUtil.cxx:1828
 TGLUtil.cxx:1829
 TGLUtil.cxx:1830
 TGLUtil.cxx:1831
 TGLUtil.cxx:1832
 TGLUtil.cxx:1833
 TGLUtil.cxx:1834
 TGLUtil.cxx:1835
 TGLUtil.cxx:1836
 TGLUtil.cxx:1837
 TGLUtil.cxx:1838
 TGLUtil.cxx:1839
 TGLUtil.cxx:1840
 TGLUtil.cxx:1841
 TGLUtil.cxx:1842
 TGLUtil.cxx:1843
 TGLUtil.cxx:1844
 TGLUtil.cxx:1845
 TGLUtil.cxx:1846
 TGLUtil.cxx:1847
 TGLUtil.cxx:1848
 TGLUtil.cxx:1849
 TGLUtil.cxx:1850
 TGLUtil.cxx:1851
 TGLUtil.cxx:1852
 TGLUtil.cxx:1853
 TGLUtil.cxx:1854
 TGLUtil.cxx:1855
 TGLUtil.cxx:1856
 TGLUtil.cxx:1857
 TGLUtil.cxx:1858
 TGLUtil.cxx:1859
 TGLUtil.cxx:1860
 TGLUtil.cxx:1861
 TGLUtil.cxx:1862
 TGLUtil.cxx:1863
 TGLUtil.cxx:1864
 TGLUtil.cxx:1865
 TGLUtil.cxx:1866
 TGLUtil.cxx:1867
 TGLUtil.cxx:1868
 TGLUtil.cxx:1869
 TGLUtil.cxx:1870
 TGLUtil.cxx:1871
 TGLUtil.cxx:1872
 TGLUtil.cxx:1873
 TGLUtil.cxx:1874
 TGLUtil.cxx:1875
 TGLUtil.cxx:1876
 TGLUtil.cxx:1877
 TGLUtil.cxx:1878
 TGLUtil.cxx:1879
 TGLUtil.cxx:1880
 TGLUtil.cxx:1881
 TGLUtil.cxx:1882
 TGLUtil.cxx:1883
 TGLUtil.cxx:1884
 TGLUtil.cxx:1885
 TGLUtil.cxx:1886
 TGLUtil.cxx:1887
 TGLUtil.cxx:1888
 TGLUtil.cxx:1889
 TGLUtil.cxx:1890
 TGLUtil.cxx:1891
 TGLUtil.cxx:1892
 TGLUtil.cxx:1893
 TGLUtil.cxx:1894
 TGLUtil.cxx:1895
 TGLUtil.cxx:1896
 TGLUtil.cxx:1897
 TGLUtil.cxx:1898
 TGLUtil.cxx:1899
 TGLUtil.cxx:1900
 TGLUtil.cxx:1901
 TGLUtil.cxx:1902
 TGLUtil.cxx:1903
 TGLUtil.cxx:1904
 TGLUtil.cxx:1905
 TGLUtil.cxx:1906
 TGLUtil.cxx:1907
 TGLUtil.cxx:1908
 TGLUtil.cxx:1909
 TGLUtil.cxx:1910
 TGLUtil.cxx:1911
 TGLUtil.cxx:1912
 TGLUtil.cxx:1913
 TGLUtil.cxx:1914
 TGLUtil.cxx:1915
 TGLUtil.cxx:1916
 TGLUtil.cxx:1917
 TGLUtil.cxx:1918
 TGLUtil.cxx:1919
 TGLUtil.cxx:1920
 TGLUtil.cxx:1921
 TGLUtil.cxx:1922
 TGLUtil.cxx:1923
 TGLUtil.cxx:1924
 TGLUtil.cxx:1925
 TGLUtil.cxx:1926
 TGLUtil.cxx:1927
 TGLUtil.cxx:1928
 TGLUtil.cxx:1929
 TGLUtil.cxx:1930
 TGLUtil.cxx:1931
 TGLUtil.cxx:1932
 TGLUtil.cxx:1933
 TGLUtil.cxx:1934
 TGLUtil.cxx:1935
 TGLUtil.cxx:1936
 TGLUtil.cxx:1937
 TGLUtil.cxx:1938
 TGLUtil.cxx:1939
 TGLUtil.cxx:1940
 TGLUtil.cxx:1941
 TGLUtil.cxx:1942
 TGLUtil.cxx:1943
 TGLUtil.cxx:1944
 TGLUtil.cxx:1945
 TGLUtil.cxx:1946
 TGLUtil.cxx:1947
 TGLUtil.cxx:1948
 TGLUtil.cxx:1949
 TGLUtil.cxx:1950
 TGLUtil.cxx:1951
 TGLUtil.cxx:1952
 TGLUtil.cxx:1953
 TGLUtil.cxx:1954
 TGLUtil.cxx:1955
 TGLUtil.cxx:1956
 TGLUtil.cxx:1957
 TGLUtil.cxx:1958
 TGLUtil.cxx:1959
 TGLUtil.cxx:1960
 TGLUtil.cxx:1961
 TGLUtil.cxx:1962
 TGLUtil.cxx:1963
 TGLUtil.cxx:1964
 TGLUtil.cxx:1965
 TGLUtil.cxx:1966
 TGLUtil.cxx:1967
 TGLUtil.cxx:1968
 TGLUtil.cxx:1969
 TGLUtil.cxx:1970
 TGLUtil.cxx:1971
 TGLUtil.cxx:1972
 TGLUtil.cxx:1973
 TGLUtil.cxx:1974
 TGLUtil.cxx:1975
 TGLUtil.cxx:1976
 TGLUtil.cxx:1977
 TGLUtil.cxx:1978
 TGLUtil.cxx:1979
 TGLUtil.cxx:1980
 TGLUtil.cxx:1981
 TGLUtil.cxx:1982
 TGLUtil.cxx:1983
 TGLUtil.cxx:1984
 TGLUtil.cxx:1985
 TGLUtil.cxx:1986
 TGLUtil.cxx:1987
 TGLUtil.cxx:1988
 TGLUtil.cxx:1989
 TGLUtil.cxx:1990
 TGLUtil.cxx:1991
 TGLUtil.cxx:1992
 TGLUtil.cxx:1993
 TGLUtil.cxx:1994
 TGLUtil.cxx:1995
 TGLUtil.cxx:1996
 TGLUtil.cxx:1997
 TGLUtil.cxx:1998
 TGLUtil.cxx:1999
 TGLUtil.cxx:2000
 TGLUtil.cxx:2001
 TGLUtil.cxx:2002
 TGLUtil.cxx:2003
 TGLUtil.cxx:2004
 TGLUtil.cxx:2005
 TGLUtil.cxx:2006
 TGLUtil.cxx:2007
 TGLUtil.cxx:2008
 TGLUtil.cxx:2009
 TGLUtil.cxx:2010
 TGLUtil.cxx:2011
 TGLUtil.cxx:2012
 TGLUtil.cxx:2013
 TGLUtil.cxx:2014
 TGLUtil.cxx:2015
 TGLUtil.cxx:2016
 TGLUtil.cxx:2017
 TGLUtil.cxx:2018
 TGLUtil.cxx:2019
 TGLUtil.cxx:2020
 TGLUtil.cxx:2021
 TGLUtil.cxx:2022
 TGLUtil.cxx:2023
 TGLUtil.cxx:2024
 TGLUtil.cxx:2025
 TGLUtil.cxx:2026
 TGLUtil.cxx:2027
 TGLUtil.cxx:2028
 TGLUtil.cxx:2029
 TGLUtil.cxx:2030
 TGLUtil.cxx:2031
 TGLUtil.cxx:2032
 TGLUtil.cxx:2033
 TGLUtil.cxx:2034
 TGLUtil.cxx:2035
 TGLUtil.cxx:2036
 TGLUtil.cxx:2037
 TGLUtil.cxx:2038
 TGLUtil.cxx:2039
 TGLUtil.cxx:2040
 TGLUtil.cxx:2041
 TGLUtil.cxx:2042
 TGLUtil.cxx:2043
 TGLUtil.cxx:2044
 TGLUtil.cxx:2045
 TGLUtil.cxx:2046
 TGLUtil.cxx:2047
 TGLUtil.cxx:2048
 TGLUtil.cxx:2049
 TGLUtil.cxx:2050
 TGLUtil.cxx:2051
 TGLUtil.cxx:2052
 TGLUtil.cxx:2053
 TGLUtil.cxx:2054
 TGLUtil.cxx:2055
 TGLUtil.cxx:2056
 TGLUtil.cxx:2057
 TGLUtil.cxx:2058
 TGLUtil.cxx:2059
 TGLUtil.cxx:2060
 TGLUtil.cxx:2061
 TGLUtil.cxx:2062
 TGLUtil.cxx:2063
 TGLUtil.cxx:2064
 TGLUtil.cxx:2065
 TGLUtil.cxx:2066
 TGLUtil.cxx:2067
 TGLUtil.cxx:2068
 TGLUtil.cxx:2069
 TGLUtil.cxx:2070
 TGLUtil.cxx:2071
 TGLUtil.cxx:2072
 TGLUtil.cxx:2073
 TGLUtil.cxx:2074
 TGLUtil.cxx:2075
 TGLUtil.cxx:2076
 TGLUtil.cxx:2077
 TGLUtil.cxx:2078
 TGLUtil.cxx:2079
 TGLUtil.cxx:2080
 TGLUtil.cxx:2081
 TGLUtil.cxx:2082
 TGLUtil.cxx:2083
 TGLUtil.cxx:2084
 TGLUtil.cxx:2085
 TGLUtil.cxx:2086
 TGLUtil.cxx:2087
 TGLUtil.cxx:2088
 TGLUtil.cxx:2089
 TGLUtil.cxx:2090
 TGLUtil.cxx:2091
 TGLUtil.cxx:2092
 TGLUtil.cxx:2093
 TGLUtil.cxx:2094
 TGLUtil.cxx:2095
 TGLUtil.cxx:2096
 TGLUtil.cxx:2097
 TGLUtil.cxx:2098
 TGLUtil.cxx:2099
 TGLUtil.cxx:2100
 TGLUtil.cxx:2101
 TGLUtil.cxx:2102
 TGLUtil.cxx:2103
 TGLUtil.cxx:2104
 TGLUtil.cxx:2105
 TGLUtil.cxx:2106
 TGLUtil.cxx:2107
 TGLUtil.cxx:2108
 TGLUtil.cxx:2109
 TGLUtil.cxx:2110
 TGLUtil.cxx:2111
 TGLUtil.cxx:2112
 TGLUtil.cxx:2113
 TGLUtil.cxx:2114
 TGLUtil.cxx:2115
 TGLUtil.cxx:2116
 TGLUtil.cxx:2117
 TGLUtil.cxx:2118
 TGLUtil.cxx:2119
 TGLUtil.cxx:2120
 TGLUtil.cxx:2121
 TGLUtil.cxx:2122
 TGLUtil.cxx:2123
 TGLUtil.cxx:2124
 TGLUtil.cxx:2125
 TGLUtil.cxx:2126
 TGLUtil.cxx:2127
 TGLUtil.cxx:2128
 TGLUtil.cxx:2129
 TGLUtil.cxx:2130
 TGLUtil.cxx:2131
 TGLUtil.cxx:2132
 TGLUtil.cxx:2133
 TGLUtil.cxx:2134
 TGLUtil.cxx:2135
 TGLUtil.cxx:2136
 TGLUtil.cxx:2137
 TGLUtil.cxx:2138
 TGLUtil.cxx:2139
 TGLUtil.cxx:2140
 TGLUtil.cxx:2141
 TGLUtil.cxx:2142
 TGLUtil.cxx:2143
 TGLUtil.cxx:2144
 TGLUtil.cxx:2145
 TGLUtil.cxx:2146
 TGLUtil.cxx:2147
 TGLUtil.cxx:2148
 TGLUtil.cxx:2149
 TGLUtil.cxx:2150
 TGLUtil.cxx:2151
 TGLUtil.cxx:2152
 TGLUtil.cxx:2153
 TGLUtil.cxx:2154
 TGLUtil.cxx:2155
 TGLUtil.cxx:2156
 TGLUtil.cxx:2157
 TGLUtil.cxx:2158
 TGLUtil.cxx:2159
 TGLUtil.cxx:2160
 TGLUtil.cxx:2161
 TGLUtil.cxx:2162
 TGLUtil.cxx:2163
 TGLUtil.cxx:2164
 TGLUtil.cxx:2165
 TGLUtil.cxx:2166
 TGLUtil.cxx:2167
 TGLUtil.cxx:2168
 TGLUtil.cxx:2169
 TGLUtil.cxx:2170
 TGLUtil.cxx:2171
 TGLUtil.cxx:2172
 TGLUtil.cxx:2173
 TGLUtil.cxx:2174
 TGLUtil.cxx:2175
 TGLUtil.cxx:2176
 TGLUtil.cxx:2177
 TGLUtil.cxx:2178
 TGLUtil.cxx:2179
 TGLUtil.cxx:2180
 TGLUtil.cxx:2181
 TGLUtil.cxx:2182
 TGLUtil.cxx:2183
 TGLUtil.cxx:2184
 TGLUtil.cxx:2185
 TGLUtil.cxx:2186
 TGLUtil.cxx:2187
 TGLUtil.cxx:2188
 TGLUtil.cxx:2189
 TGLUtil.cxx:2190
 TGLUtil.cxx:2191
 TGLUtil.cxx:2192
 TGLUtil.cxx:2193
 TGLUtil.cxx:2194
 TGLUtil.cxx:2195
 TGLUtil.cxx:2196
 TGLUtil.cxx:2197
 TGLUtil.cxx:2198
 TGLUtil.cxx:2199
 TGLUtil.cxx:2200
 TGLUtil.cxx:2201
 TGLUtil.cxx:2202
 TGLUtil.cxx:2203
 TGLUtil.cxx:2204
 TGLUtil.cxx:2205
 TGLUtil.cxx:2206
 TGLUtil.cxx:2207
 TGLUtil.cxx:2208
 TGLUtil.cxx:2209
 TGLUtil.cxx:2210
 TGLUtil.cxx:2211
 TGLUtil.cxx:2212
 TGLUtil.cxx:2213
 TGLUtil.cxx:2214
 TGLUtil.cxx:2215
 TGLUtil.cxx:2216
 TGLUtil.cxx:2217
 TGLUtil.cxx:2218
 TGLUtil.cxx:2219
 TGLUtil.cxx:2220
 TGLUtil.cxx:2221
 TGLUtil.cxx:2222
 TGLUtil.cxx:2223
 TGLUtil.cxx:2224
 TGLUtil.cxx:2225
 TGLUtil.cxx:2226
 TGLUtil.cxx:2227
 TGLUtil.cxx:2228
 TGLUtil.cxx:2229
 TGLUtil.cxx:2230
 TGLUtil.cxx:2231
 TGLUtil.cxx:2232
 TGLUtil.cxx:2233
 TGLUtil.cxx:2234
 TGLUtil.cxx:2235
 TGLUtil.cxx:2236
 TGLUtil.cxx:2237
 TGLUtil.cxx:2238
 TGLUtil.cxx:2239
 TGLUtil.cxx:2240
 TGLUtil.cxx:2241
 TGLUtil.cxx:2242
 TGLUtil.cxx:2243
 TGLUtil.cxx:2244
 TGLUtil.cxx:2245
 TGLUtil.cxx:2246
 TGLUtil.cxx:2247
 TGLUtil.cxx:2248
 TGLUtil.cxx:2249
 TGLUtil.cxx:2250
 TGLUtil.cxx:2251
 TGLUtil.cxx:2252
 TGLUtil.cxx:2253
 TGLUtil.cxx:2254
 TGLUtil.cxx:2255
 TGLUtil.cxx:2256
 TGLUtil.cxx:2257
 TGLUtil.cxx:2258
 TGLUtil.cxx:2259
 TGLUtil.cxx:2260
 TGLUtil.cxx:2261
 TGLUtil.cxx:2262
 TGLUtil.cxx:2263
 TGLUtil.cxx:2264
 TGLUtil.cxx:2265
 TGLUtil.cxx:2266
 TGLUtil.cxx:2267
 TGLUtil.cxx:2268
 TGLUtil.cxx:2269
 TGLUtil.cxx:2270
 TGLUtil.cxx:2271
 TGLUtil.cxx:2272
 TGLUtil.cxx:2273
 TGLUtil.cxx:2274
 TGLUtil.cxx:2275
 TGLUtil.cxx:2276
 TGLUtil.cxx:2277
 TGLUtil.cxx:2278
 TGLUtil.cxx:2279
 TGLUtil.cxx:2280
 TGLUtil.cxx:2281
 TGLUtil.cxx:2282
 TGLUtil.cxx:2283
 TGLUtil.cxx:2284
 TGLUtil.cxx:2285
 TGLUtil.cxx:2286
 TGLUtil.cxx:2287
 TGLUtil.cxx:2288
 TGLUtil.cxx:2289
 TGLUtil.cxx:2290
 TGLUtil.cxx:2291
 TGLUtil.cxx:2292
 TGLUtil.cxx:2293
 TGLUtil.cxx:2294
 TGLUtil.cxx:2295
 TGLUtil.cxx:2296
 TGLUtil.cxx:2297
 TGLUtil.cxx:2298
 TGLUtil.cxx:2299
 TGLUtil.cxx:2300
 TGLUtil.cxx:2301
 TGLUtil.cxx:2302
 TGLUtil.cxx:2303
 TGLUtil.cxx:2304
 TGLUtil.cxx:2305
 TGLUtil.cxx:2306
 TGLUtil.cxx:2307
 TGLUtil.cxx:2308
 TGLUtil.cxx:2309
 TGLUtil.cxx:2310
 TGLUtil.cxx:2311
 TGLUtil.cxx:2312
 TGLUtil.cxx:2313
 TGLUtil.cxx:2314
 TGLUtil.cxx:2315
 TGLUtil.cxx:2316
 TGLUtil.cxx:2317
 TGLUtil.cxx:2318
 TGLUtil.cxx:2319
 TGLUtil.cxx:2320
 TGLUtil.cxx:2321
 TGLUtil.cxx:2322
 TGLUtil.cxx:2323
 TGLUtil.cxx:2324
 TGLUtil.cxx:2325
 TGLUtil.cxx:2326
 TGLUtil.cxx:2327
 TGLUtil.cxx:2328
 TGLUtil.cxx:2329
 TGLUtil.cxx:2330
 TGLUtil.cxx:2331
 TGLUtil.cxx:2332
 TGLUtil.cxx:2333
 TGLUtil.cxx:2334
 TGLUtil.cxx:2335
 TGLUtil.cxx:2336
 TGLUtil.cxx:2337
 TGLUtil.cxx:2338
 TGLUtil.cxx:2339
 TGLUtil.cxx:2340
 TGLUtil.cxx:2341
 TGLUtil.cxx:2342
 TGLUtil.cxx:2343
 TGLUtil.cxx:2344
 TGLUtil.cxx:2345
 TGLUtil.cxx:2346
 TGLUtil.cxx:2347
 TGLUtil.cxx:2348
 TGLUtil.cxx:2349
 TGLUtil.cxx:2350
 TGLUtil.cxx:2351
 TGLUtil.cxx:2352
 TGLUtil.cxx:2353
 TGLUtil.cxx:2354
 TGLUtil.cxx:2355
 TGLUtil.cxx:2356
 TGLUtil.cxx:2357
 TGLUtil.cxx:2358
 TGLUtil.cxx:2359
 TGLUtil.cxx:2360
 TGLUtil.cxx:2361
 TGLUtil.cxx:2362
 TGLUtil.cxx:2363
 TGLUtil.cxx:2364
 TGLUtil.cxx:2365
 TGLUtil.cxx:2366
 TGLUtil.cxx:2367
 TGLUtil.cxx:2368
 TGLUtil.cxx:2369
 TGLUtil.cxx:2370
 TGLUtil.cxx:2371
 TGLUtil.cxx:2372
 TGLUtil.cxx:2373
 TGLUtil.cxx:2374
 TGLUtil.cxx:2375
 TGLUtil.cxx:2376
 TGLUtil.cxx:2377
 TGLUtil.cxx:2378
 TGLUtil.cxx:2379
 TGLUtil.cxx:2380
 TGLUtil.cxx:2381
 TGLUtil.cxx:2382
 TGLUtil.cxx:2383
 TGLUtil.cxx:2384
 TGLUtil.cxx:2385
 TGLUtil.cxx:2386
 TGLUtil.cxx:2387
 TGLUtil.cxx:2388
 TGLUtil.cxx:2389
 TGLUtil.cxx:2390
 TGLUtil.cxx:2391
 TGLUtil.cxx:2392
 TGLUtil.cxx:2393
 TGLUtil.cxx:2394
 TGLUtil.cxx:2395
 TGLUtil.cxx:2396
 TGLUtil.cxx:2397
 TGLUtil.cxx:2398
 TGLUtil.cxx:2399
 TGLUtil.cxx:2400
 TGLUtil.cxx:2401
 TGLUtil.cxx:2402
 TGLUtil.cxx:2403
 TGLUtil.cxx:2404
 TGLUtil.cxx:2405
 TGLUtil.cxx:2406
 TGLUtil.cxx:2407
 TGLUtil.cxx:2408
 TGLUtil.cxx:2409
 TGLUtil.cxx:2410
 TGLUtil.cxx:2411
 TGLUtil.cxx:2412
 TGLUtil.cxx:2413
 TGLUtil.cxx:2414
 TGLUtil.cxx:2415
 TGLUtil.cxx:2416
 TGLUtil.cxx:2417
 TGLUtil.cxx:2418
 TGLUtil.cxx:2419
 TGLUtil.cxx:2420
 TGLUtil.cxx:2421
 TGLUtil.cxx:2422
 TGLUtil.cxx:2423
 TGLUtil.cxx:2424
 TGLUtil.cxx:2425
 TGLUtil.cxx:2426
 TGLUtil.cxx:2427
 TGLUtil.cxx:2428
 TGLUtil.cxx:2429
 TGLUtil.cxx:2430
 TGLUtil.cxx:2431
 TGLUtil.cxx:2432
 TGLUtil.cxx:2433
 TGLUtil.cxx:2434
 TGLUtil.cxx:2435
 TGLUtil.cxx:2436
 TGLUtil.cxx:2437
 TGLUtil.cxx:2438
 TGLUtil.cxx:2439
 TGLUtil.cxx:2440
 TGLUtil.cxx:2441
 TGLUtil.cxx:2442
 TGLUtil.cxx:2443
 TGLUtil.cxx:2444
 TGLUtil.cxx:2445
 TGLUtil.cxx:2446
 TGLUtil.cxx:2447
 TGLUtil.cxx:2448
 TGLUtil.cxx:2449
 TGLUtil.cxx:2450
 TGLUtil.cxx:2451
 TGLUtil.cxx:2452
 TGLUtil.cxx:2453
 TGLUtil.cxx:2454
 TGLUtil.cxx:2455
 TGLUtil.cxx:2456
 TGLUtil.cxx:2457
 TGLUtil.cxx:2458
 TGLUtil.cxx:2459
 TGLUtil.cxx:2460
 TGLUtil.cxx:2461
 TGLUtil.cxx:2462
 TGLUtil.cxx:2463
 TGLUtil.cxx:2464
 TGLUtil.cxx:2465
 TGLUtil.cxx:2466
 TGLUtil.cxx:2467
 TGLUtil.cxx:2468
 TGLUtil.cxx:2469
 TGLUtil.cxx:2470
 TGLUtil.cxx:2471
 TGLUtil.cxx:2472
 TGLUtil.cxx:2473
 TGLUtil.cxx:2474
 TGLUtil.cxx:2475
 TGLUtil.cxx:2476
 TGLUtil.cxx:2477
 TGLUtil.cxx:2478
 TGLUtil.cxx:2479
 TGLUtil.cxx:2480
 TGLUtil.cxx:2481
 TGLUtil.cxx:2482
 TGLUtil.cxx:2483
 TGLUtil.cxx:2484
 TGLUtil.cxx:2485
 TGLUtil.cxx:2486
 TGLUtil.cxx:2487
 TGLUtil.cxx:2488
 TGLUtil.cxx:2489
 TGLUtil.cxx:2490
 TGLUtil.cxx:2491
 TGLUtil.cxx:2492
 TGLUtil.cxx:2493
 TGLUtil.cxx:2494
 TGLUtil.cxx:2495
 TGLUtil.cxx:2496
 TGLUtil.cxx:2497
 TGLUtil.cxx:2498
 TGLUtil.cxx:2499
 TGLUtil.cxx:2500
 TGLUtil.cxx:2501
 TGLUtil.cxx:2502
 TGLUtil.cxx:2503
 TGLUtil.cxx:2504
 TGLUtil.cxx:2505
 TGLUtil.cxx:2506
 TGLUtil.cxx:2507
 TGLUtil.cxx:2508
 TGLUtil.cxx:2509
 TGLUtil.cxx:2510
 TGLUtil.cxx:2511
 TGLUtil.cxx:2512
 TGLUtil.cxx:2513
 TGLUtil.cxx:2514
 TGLUtil.cxx:2515
 TGLUtil.cxx:2516
 TGLUtil.cxx:2517
 TGLUtil.cxx:2518
 TGLUtil.cxx:2519
 TGLUtil.cxx:2520
 TGLUtil.cxx:2521
 TGLUtil.cxx:2522
 TGLUtil.cxx:2523
 TGLUtil.cxx:2524
 TGLUtil.cxx:2525
 TGLUtil.cxx:2526
 TGLUtil.cxx:2527
 TGLUtil.cxx:2528
 TGLUtil.cxx:2529
 TGLUtil.cxx:2530
 TGLUtil.cxx:2531
 TGLUtil.cxx:2532
 TGLUtil.cxx:2533
 TGLUtil.cxx:2534
 TGLUtil.cxx:2535
 TGLUtil.cxx:2536
 TGLUtil.cxx:2537
 TGLUtil.cxx:2538
 TGLUtil.cxx:2539
 TGLUtil.cxx:2540
 TGLUtil.cxx:2541
 TGLUtil.cxx:2542
 TGLUtil.cxx:2543
 TGLUtil.cxx:2544
 TGLUtil.cxx:2545
 TGLUtil.cxx:2546
 TGLUtil.cxx:2547
 TGLUtil.cxx:2548
 TGLUtil.cxx:2549
 TGLUtil.cxx:2550
 TGLUtil.cxx:2551
 TGLUtil.cxx:2552
 TGLUtil.cxx:2553
 TGLUtil.cxx:2554
 TGLUtil.cxx:2555
 TGLUtil.cxx:2556
 TGLUtil.cxx:2557
 TGLUtil.cxx:2558
 TGLUtil.cxx:2559
 TGLUtil.cxx:2560
 TGLUtil.cxx:2561
 TGLUtil.cxx:2562
 TGLUtil.cxx:2563
 TGLUtil.cxx:2564
 TGLUtil.cxx:2565
 TGLUtil.cxx:2566
 TGLUtil.cxx:2567
 TGLUtil.cxx:2568
 TGLUtil.cxx:2569
 TGLUtil.cxx:2570
 TGLUtil.cxx:2571
 TGLUtil.cxx:2572
 TGLUtil.cxx:2573
 TGLUtil.cxx:2574
 TGLUtil.cxx:2575
 TGLUtil.cxx:2576
 TGLUtil.cxx:2577
 TGLUtil.cxx:2578
 TGLUtil.cxx:2579
 TGLUtil.cxx:2580
 TGLUtil.cxx:2581
 TGLUtil.cxx:2582
 TGLUtil.cxx:2583
 TGLUtil.cxx:2584
 TGLUtil.cxx:2585
 TGLUtil.cxx:2586
 TGLUtil.cxx:2587
 TGLUtil.cxx:2588
 TGLUtil.cxx:2589
 TGLUtil.cxx:2590
 TGLUtil.cxx:2591
 TGLUtil.cxx:2592
 TGLUtil.cxx:2593
 TGLUtil.cxx:2594
 TGLUtil.cxx:2595
 TGLUtil.cxx:2596
 TGLUtil.cxx:2597
 TGLUtil.cxx:2598
 TGLUtil.cxx:2599
 TGLUtil.cxx:2600
 TGLUtil.cxx:2601
 TGLUtil.cxx:2602
 TGLUtil.cxx:2603
 TGLUtil.cxx:2604
 TGLUtil.cxx:2605
 TGLUtil.cxx:2606
 TGLUtil.cxx:2607
 TGLUtil.cxx:2608
 TGLUtil.cxx:2609
 TGLUtil.cxx:2610
 TGLUtil.cxx:2611
 TGLUtil.cxx:2612
 TGLUtil.cxx:2613
 TGLUtil.cxx:2614
 TGLUtil.cxx:2615
 TGLUtil.cxx:2616
 TGLUtil.cxx:2617
 TGLUtil.cxx:2618
 TGLUtil.cxx:2619
 TGLUtil.cxx:2620
 TGLUtil.cxx:2621
 TGLUtil.cxx:2622
 TGLUtil.cxx:2623
 TGLUtil.cxx:2624
 TGLUtil.cxx:2625
 TGLUtil.cxx:2626
 TGLUtil.cxx:2627
 TGLUtil.cxx:2628
 TGLUtil.cxx:2629
 TGLUtil.cxx:2630
 TGLUtil.cxx:2631
 TGLUtil.cxx:2632
 TGLUtil.cxx:2633
 TGLUtil.cxx:2634
 TGLUtil.cxx:2635
 TGLUtil.cxx:2636
 TGLUtil.cxx:2637
 TGLUtil.cxx:2638
 TGLUtil.cxx:2639
 TGLUtil.cxx:2640
 TGLUtil.cxx:2641
 TGLUtil.cxx:2642
 TGLUtil.cxx:2643
 TGLUtil.cxx:2644
 TGLUtil.cxx:2645
 TGLUtil.cxx:2646
 TGLUtil.cxx:2647
 TGLUtil.cxx:2648
 TGLUtil.cxx:2649
 TGLUtil.cxx:2650
 TGLUtil.cxx:2651
 TGLUtil.cxx:2652
 TGLUtil.cxx:2653
 TGLUtil.cxx:2654
 TGLUtil.cxx:2655
 TGLUtil.cxx:2656
 TGLUtil.cxx:2657
 TGLUtil.cxx:2658
 TGLUtil.cxx:2659
 TGLUtil.cxx:2660
 TGLUtil.cxx:2661
 TGLUtil.cxx:2662
 TGLUtil.cxx:2663
 TGLUtil.cxx:2664
 TGLUtil.cxx:2665
 TGLUtil.cxx:2666
 TGLUtil.cxx:2667
 TGLUtil.cxx:2668
 TGLUtil.cxx:2669
 TGLUtil.cxx:2670
 TGLUtil.cxx:2671
 TGLUtil.cxx:2672
 TGLUtil.cxx:2673
 TGLUtil.cxx:2674
 TGLUtil.cxx:2675
 TGLUtil.cxx:2676
 TGLUtil.cxx:2677
 TGLUtil.cxx:2678
 TGLUtil.cxx:2679
 TGLUtil.cxx:2680
 TGLUtil.cxx:2681
 TGLUtil.cxx:2682
 TGLUtil.cxx:2683
 TGLUtil.cxx:2684
 TGLUtil.cxx:2685
 TGLUtil.cxx:2686
 TGLUtil.cxx:2687
 TGLUtil.cxx:2688
 TGLUtil.cxx:2689
 TGLUtil.cxx:2690
 TGLUtil.cxx:2691
 TGLUtil.cxx:2692
 TGLUtil.cxx:2693
 TGLUtil.cxx:2694
 TGLUtil.cxx:2695
 TGLUtil.cxx:2696
 TGLUtil.cxx:2697
 TGLUtil.cxx:2698
 TGLUtil.cxx:2699
 TGLUtil.cxx:2700
 TGLUtil.cxx:2701
 TGLUtil.cxx:2702
 TGLUtil.cxx:2703
 TGLUtil.cxx:2704
 TGLUtil.cxx:2705
 TGLUtil.cxx:2706
 TGLUtil.cxx:2707
 TGLUtil.cxx:2708
 TGLUtil.cxx:2709
 TGLUtil.cxx:2710
 TGLUtil.cxx:2711
 TGLUtil.cxx:2712
 TGLUtil.cxx:2713
 TGLUtil.cxx:2714
 TGLUtil.cxx:2715
 TGLUtil.cxx:2716
 TGLUtil.cxx:2717
 TGLUtil.cxx:2718
 TGLUtil.cxx:2719
 TGLUtil.cxx:2720
 TGLUtil.cxx:2721
 TGLUtil.cxx:2722
 TGLUtil.cxx:2723
 TGLUtil.cxx:2724
 TGLUtil.cxx:2725
 TGLUtil.cxx:2726
 TGLUtil.cxx:2727
 TGLUtil.cxx:2728
 TGLUtil.cxx:2729
 TGLUtil.cxx:2730
 TGLUtil.cxx:2731
 TGLUtil.cxx:2732
 TGLUtil.cxx:2733
 TGLUtil.cxx:2734
 TGLUtil.cxx:2735
 TGLUtil.cxx:2736
 TGLUtil.cxx:2737
 TGLUtil.cxx:2738
 TGLUtil.cxx:2739
 TGLUtil.cxx:2740
 TGLUtil.cxx:2741
 TGLUtil.cxx:2742
 TGLUtil.cxx:2743
 TGLUtil.cxx:2744
 TGLUtil.cxx:2745
 TGLUtil.cxx:2746
 TGLUtil.cxx:2747
 TGLUtil.cxx:2748
 TGLUtil.cxx:2749
 TGLUtil.cxx:2750
 TGLUtil.cxx:2751
 TGLUtil.cxx:2752
 TGLUtil.cxx:2753
 TGLUtil.cxx:2754
 TGLUtil.cxx:2755
 TGLUtil.cxx:2756
 TGLUtil.cxx:2757
 TGLUtil.cxx:2758
 TGLUtil.cxx:2759
 TGLUtil.cxx:2760
 TGLUtil.cxx:2761
 TGLUtil.cxx:2762
 TGLUtil.cxx:2763
 TGLUtil.cxx:2764
 TGLUtil.cxx:2765
 TGLUtil.cxx:2766
 TGLUtil.cxx:2767
 TGLUtil.cxx:2768
 TGLUtil.cxx:2769
 TGLUtil.cxx:2770
 TGLUtil.cxx:2771
 TGLUtil.cxx:2772
 TGLUtil.cxx:2773
 TGLUtil.cxx:2774
 TGLUtil.cxx:2775
 TGLUtil.cxx:2776
 TGLUtil.cxx:2777
 TGLUtil.cxx:2778
 TGLUtil.cxx:2779
 TGLUtil.cxx:2780
 TGLUtil.cxx:2781
 TGLUtil.cxx:2782
 TGLUtil.cxx:2783
 TGLUtil.cxx:2784
 TGLUtil.cxx:2785
 TGLUtil.cxx:2786
 TGLUtil.cxx:2787
 TGLUtil.cxx:2788
 TGLUtil.cxx:2789
 TGLUtil.cxx:2790
 TGLUtil.cxx:2791
 TGLUtil.cxx:2792
 TGLUtil.cxx:2793
 TGLUtil.cxx:2794
 TGLUtil.cxx:2795
 TGLUtil.cxx:2796
 TGLUtil.cxx:2797
 TGLUtil.cxx:2798
 TGLUtil.cxx:2799
 TGLUtil.cxx:2800
 TGLUtil.cxx:2801
 TGLUtil.cxx:2802
 TGLUtil.cxx:2803
 TGLUtil.cxx:2804
 TGLUtil.cxx:2805
 TGLUtil.cxx:2806
 TGLUtil.cxx:2807
 TGLUtil.cxx:2808
 TGLUtil.cxx:2809
 TGLUtil.cxx:2810
 TGLUtil.cxx:2811
 TGLUtil.cxx:2812
 TGLUtil.cxx:2813
 TGLUtil.cxx:2814
 TGLUtil.cxx:2815
 TGLUtil.cxx:2816
 TGLUtil.cxx:2817
 TGLUtil.cxx:2818
 TGLUtil.cxx:2819
 TGLUtil.cxx:2820
 TGLUtil.cxx:2821
 TGLUtil.cxx:2822
 TGLUtil.cxx:2823
 TGLUtil.cxx:2824
 TGLUtil.cxx:2825
 TGLUtil.cxx:2826
 TGLUtil.cxx:2827
 TGLUtil.cxx:2828
 TGLUtil.cxx:2829
 TGLUtil.cxx:2830
 TGLUtil.cxx:2831
 TGLUtil.cxx:2832
 TGLUtil.cxx:2833
 TGLUtil.cxx:2834
 TGLUtil.cxx:2835
 TGLUtil.cxx:2836
 TGLUtil.cxx:2837
 TGLUtil.cxx:2838
 TGLUtil.cxx:2839
 TGLUtil.cxx:2840
 TGLUtil.cxx:2841
 TGLUtil.cxx:2842
 TGLUtil.cxx:2843
 TGLUtil.cxx:2844
 TGLUtil.cxx:2845
 TGLUtil.cxx:2846
 TGLUtil.cxx:2847
 TGLUtil.cxx:2848
 TGLUtil.cxx:2849
 TGLUtil.cxx:2850
 TGLUtil.cxx:2851
 TGLUtil.cxx:2852
 TGLUtil.cxx:2853
 TGLUtil.cxx:2854
 TGLUtil.cxx:2855
 TGLUtil.cxx:2856
 TGLUtil.cxx:2857
 TGLUtil.cxx:2858
 TGLUtil.cxx:2859
 TGLUtil.cxx:2860
 TGLUtil.cxx:2861
 TGLUtil.cxx:2862
 TGLUtil.cxx:2863
 TGLUtil.cxx:2864
 TGLUtil.cxx:2865
 TGLUtil.cxx:2866
 TGLUtil.cxx:2867
 TGLUtil.cxx:2868
 TGLUtil.cxx:2869
 TGLUtil.cxx:2870
 TGLUtil.cxx:2871
 TGLUtil.cxx:2872
 TGLUtil.cxx:2873
 TGLUtil.cxx:2874
 TGLUtil.cxx:2875
 TGLUtil.cxx:2876
 TGLUtil.cxx:2877
 TGLUtil.cxx:2878
 TGLUtil.cxx:2879
 TGLUtil.cxx:2880
 TGLUtil.cxx:2881
 TGLUtil.cxx:2882
 TGLUtil.cxx:2883
 TGLUtil.cxx:2884
 TGLUtil.cxx:2885
 TGLUtil.cxx:2886
 TGLUtil.cxx:2887
 TGLUtil.cxx:2888
 TGLUtil.cxx:2889
 TGLUtil.cxx:2890
 TGLUtil.cxx:2891
 TGLUtil.cxx:2892
 TGLUtil.cxx:2893
 TGLUtil.cxx:2894
 TGLUtil.cxx:2895
 TGLUtil.cxx:2896
 TGLUtil.cxx:2897
 TGLUtil.cxx:2898
 TGLUtil.cxx:2899
 TGLUtil.cxx:2900
 TGLUtil.cxx:2901
 TGLUtil.cxx:2902
 TGLUtil.cxx:2903
 TGLUtil.cxx:2904
 TGLUtil.cxx:2905
 TGLUtil.cxx:2906
 TGLUtil.cxx:2907
 TGLUtil.cxx:2908
 TGLUtil.cxx:2909
 TGLUtil.cxx:2910
 TGLUtil.cxx:2911
 TGLUtil.cxx:2912
 TGLUtil.cxx:2913
 TGLUtil.cxx:2914
 TGLUtil.cxx:2915
 TGLUtil.cxx:2916
 TGLUtil.cxx:2917
 TGLUtil.cxx:2918
 TGLUtil.cxx:2919
 TGLUtil.cxx:2920
 TGLUtil.cxx:2921
 TGLUtil.cxx:2922
 TGLUtil.cxx:2923
 TGLUtil.cxx:2924
 TGLUtil.cxx:2925
 TGLUtil.cxx:2926
 TGLUtil.cxx:2927
 TGLUtil.cxx:2928
 TGLUtil.cxx:2929
 TGLUtil.cxx:2930
 TGLUtil.cxx:2931
 TGLUtil.cxx:2932
 TGLUtil.cxx:2933
 TGLUtil.cxx:2934
 TGLUtil.cxx:2935
 TGLUtil.cxx:2936
 TGLUtil.cxx:2937
 TGLUtil.cxx:2938
 TGLUtil.cxx:2939
 TGLUtil.cxx:2940
 TGLUtil.cxx:2941
 TGLUtil.cxx:2942
 TGLUtil.cxx:2943
 TGLUtil.cxx:2944
 TGLUtil.cxx:2945
 TGLUtil.cxx:2946
 TGLUtil.cxx:2947
 TGLUtil.cxx:2948
 TGLUtil.cxx:2949
 TGLUtil.cxx:2950
 TGLUtil.cxx:2951
 TGLUtil.cxx:2952
 TGLUtil.cxx:2953
 TGLUtil.cxx:2954
 TGLUtil.cxx:2955
 TGLUtil.cxx:2956
 TGLUtil.cxx:2957
 TGLUtil.cxx:2958
 TGLUtil.cxx:2959
 TGLUtil.cxx:2960
 TGLUtil.cxx:2961
 TGLUtil.cxx:2962
 TGLUtil.cxx:2963
 TGLUtil.cxx:2964
 TGLUtil.cxx:2965
 TGLUtil.cxx:2966
 TGLUtil.cxx:2967
 TGLUtil.cxx:2968
 TGLUtil.cxx:2969
 TGLUtil.cxx:2970
 TGLUtil.cxx:2971
 TGLUtil.cxx:2972
 TGLUtil.cxx:2973
 TGLUtil.cxx:2974
 TGLUtil.cxx:2975
 TGLUtil.cxx:2976
 TGLUtil.cxx:2977
 TGLUtil.cxx:2978
 TGLUtil.cxx:2979
 TGLUtil.cxx:2980
 TGLUtil.cxx:2981
 TGLUtil.cxx:2982
 TGLUtil.cxx:2983
 TGLUtil.cxx:2984
 TGLUtil.cxx:2985
 TGLUtil.cxx:2986
 TGLUtil.cxx:2987
 TGLUtil.cxx:2988
 TGLUtil.cxx:2989
 TGLUtil.cxx:2990
 TGLUtil.cxx:2991
 TGLUtil.cxx:2992
 TGLUtil.cxx:2993
 TGLUtil.cxx:2994
 TGLUtil.cxx:2995
 TGLUtil.cxx:2996
 TGLUtil.cxx:2997
 TGLUtil.cxx:2998
 TGLUtil.cxx:2999
 TGLUtil.cxx:3000
 TGLUtil.cxx:3001
 TGLUtil.cxx:3002
 TGLUtil.cxx:3003
 TGLUtil.cxx:3004
 TGLUtil.cxx:3005
 TGLUtil.cxx:3006
 TGLUtil.cxx:3007
 TGLUtil.cxx:3008
 TGLUtil.cxx:3009
 TGLUtil.cxx:3010
 TGLUtil.cxx:3011
 TGLUtil.cxx:3012
 TGLUtil.cxx:3013
 TGLUtil.cxx:3014
 TGLUtil.cxx:3015
 TGLUtil.cxx:3016
 TGLUtil.cxx:3017
 TGLUtil.cxx:3018
 TGLUtil.cxx:3019
 TGLUtil.cxx:3020
 TGLUtil.cxx:3021
 TGLUtil.cxx:3022
 TGLUtil.cxx:3023
 TGLUtil.cxx:3024
 TGLUtil.cxx:3025
 TGLUtil.cxx:3026
 TGLUtil.cxx:3027
 TGLUtil.cxx:3028
 TGLUtil.cxx:3029
 TGLUtil.cxx:3030
 TGLUtil.cxx:3031
 TGLUtil.cxx:3032
 TGLUtil.cxx:3033
 TGLUtil.cxx:3034
 TGLUtil.cxx:3035
 TGLUtil.cxx:3036
 TGLUtil.cxx:3037
 TGLUtil.cxx:3038
 TGLUtil.cxx:3039
 TGLUtil.cxx:3040
 TGLUtil.cxx:3041
 TGLUtil.cxx:3042
 TGLUtil.cxx:3043
 TGLUtil.cxx:3044
 TGLUtil.cxx:3045
 TGLUtil.cxx:3046
 TGLUtil.cxx:3047
 TGLUtil.cxx:3048
 TGLUtil.cxx:3049
 TGLUtil.cxx:3050
 TGLUtil.cxx:3051
 TGLUtil.cxx:3052
 TGLUtil.cxx:3053
 TGLUtil.cxx:3054
 TGLUtil.cxx:3055
 TGLUtil.cxx:3056
 TGLUtil.cxx:3057
 TGLUtil.cxx:3058
 TGLUtil.cxx:3059
 TGLUtil.cxx:3060
 TGLUtil.cxx:3061
 TGLUtil.cxx:3062
 TGLUtil.cxx:3063
 TGLUtil.cxx:3064
 TGLUtil.cxx:3065
 TGLUtil.cxx:3066
 TGLUtil.cxx:3067
 TGLUtil.cxx:3068
 TGLUtil.cxx:3069
 TGLUtil.cxx:3070
 TGLUtil.cxx:3071
 TGLUtil.cxx:3072
 TGLUtil.cxx:3073
 TGLUtil.cxx:3074
 TGLUtil.cxx:3075
 TGLUtil.cxx:3076
 TGLUtil.cxx:3077
 TGLUtil.cxx:3078
 TGLUtil.cxx:3079
 TGLUtil.cxx:3080
 TGLUtil.cxx:3081
 TGLUtil.cxx:3082
 TGLUtil.cxx:3083
 TGLUtil.cxx:3084
 TGLUtil.cxx:3085
 TGLUtil.cxx:3086
 TGLUtil.cxx:3087
 TGLUtil.cxx:3088
 TGLUtil.cxx:3089
 TGLUtil.cxx:3090
 TGLUtil.cxx:3091
 TGLUtil.cxx:3092
 TGLUtil.cxx:3093
 TGLUtil.cxx:3094
 TGLUtil.cxx:3095
 TGLUtil.cxx:3096
 TGLUtil.cxx:3097
 TGLUtil.cxx:3098
 TGLUtil.cxx:3099
 TGLUtil.cxx:3100
 TGLUtil.cxx:3101
 TGLUtil.cxx:3102
 TGLUtil.cxx:3103
 TGLUtil.cxx:3104
 TGLUtil.cxx:3105
 TGLUtil.cxx:3106
 TGLUtil.cxx:3107
 TGLUtil.cxx:3108
 TGLUtil.cxx:3109
 TGLUtil.cxx:3110
 TGLUtil.cxx:3111
 TGLUtil.cxx:3112
 TGLUtil.cxx:3113
 TGLUtil.cxx:3114
 TGLUtil.cxx:3115
 TGLUtil.cxx:3116
 TGLUtil.cxx:3117
 TGLUtil.cxx:3118
 TGLUtil.cxx:3119
 TGLUtil.cxx:3120
 TGLUtil.cxx:3121
 TGLUtil.cxx:3122
 TGLUtil.cxx:3123
 TGLUtil.cxx:3124
 TGLUtil.cxx:3125
 TGLUtil.cxx:3126
 TGLUtil.cxx:3127
 TGLUtil.cxx:3128
 TGLUtil.cxx:3129
 TGLUtil.cxx:3130
 TGLUtil.cxx:3131
 TGLUtil.cxx:3132
 TGLUtil.cxx:3133
 TGLUtil.cxx:3134
 TGLUtil.cxx:3135
 TGLUtil.cxx:3136
 TGLUtil.cxx:3137
 TGLUtil.cxx:3138
 TGLUtil.cxx:3139
 TGLUtil.cxx:3140
 TGLUtil.cxx:3141
 TGLUtil.cxx:3142
 TGLUtil.cxx:3143
 TGLUtil.cxx:3144
 TGLUtil.cxx:3145
 TGLUtil.cxx:3146
 TGLUtil.cxx:3147
 TGLUtil.cxx:3148
 TGLUtil.cxx:3149
 TGLUtil.cxx:3150
 TGLUtil.cxx:3151
 TGLUtil.cxx:3152
 TGLUtil.cxx:3153
 TGLUtil.cxx:3154
 TGLUtil.cxx:3155
 TGLUtil.cxx:3156
 TGLUtil.cxx:3157
 TGLUtil.cxx:3158
 TGLUtil.cxx:3159
 TGLUtil.cxx:3160
 TGLUtil.cxx:3161
 TGLUtil.cxx:3162
 TGLUtil.cxx:3163
 TGLUtil.cxx:3164
 TGLUtil.cxx:3165
 TGLUtil.cxx:3166
 TGLUtil.cxx:3167
 TGLUtil.cxx:3168
 TGLUtil.cxx:3169
 TGLUtil.cxx:3170
 TGLUtil.cxx:3171
 TGLUtil.cxx:3172
 TGLUtil.cxx:3173
 TGLUtil.cxx:3174
 TGLUtil.cxx:3175
 TGLUtil.cxx:3176
 TGLUtil.cxx:3177
 TGLUtil.cxx:3178
 TGLUtil.cxx:3179
 TGLUtil.cxx:3180
 TGLUtil.cxx:3181
 TGLUtil.cxx:3182
 TGLUtil.cxx:3183
 TGLUtil.cxx:3184
 TGLUtil.cxx:3185
 TGLUtil.cxx:3186
 TGLUtil.cxx:3187
 TGLUtil.cxx:3188
 TGLUtil.cxx:3189
 TGLUtil.cxx:3190
 TGLUtil.cxx:3191
 TGLUtil.cxx:3192
 TGLUtil.cxx:3193
 TGLUtil.cxx:3194
 TGLUtil.cxx:3195
 TGLUtil.cxx:3196
 TGLUtil.cxx:3197
 TGLUtil.cxx:3198
 TGLUtil.cxx:3199
 TGLUtil.cxx:3200
 TGLUtil.cxx:3201
 TGLUtil.cxx:3202
 TGLUtil.cxx:3203
 TGLUtil.cxx:3204
 TGLUtil.cxx:3205
 TGLUtil.cxx:3206
 TGLUtil.cxx:3207
 TGLUtil.cxx:3208
 TGLUtil.cxx:3209
 TGLUtil.cxx:3210
 TGLUtil.cxx:3211
 TGLUtil.cxx:3212
 TGLUtil.cxx:3213
 TGLUtil.cxx:3214
 TGLUtil.cxx:3215
 TGLUtil.cxx:3216
 TGLUtil.cxx:3217
 TGLUtil.cxx:3218
 TGLUtil.cxx:3219
 TGLUtil.cxx:3220
 TGLUtil.cxx:3221
 TGLUtil.cxx:3222
 TGLUtil.cxx:3223
 TGLUtil.cxx:3224
 TGLUtil.cxx:3225
 TGLUtil.cxx:3226
 TGLUtil.cxx:3227
 TGLUtil.cxx:3228
 TGLUtil.cxx:3229
 TGLUtil.cxx:3230
 TGLUtil.cxx:3231
 TGLUtil.cxx:3232
 TGLUtil.cxx:3233
 TGLUtil.cxx:3234
 TGLUtil.cxx:3235
 TGLUtil.cxx:3236
 TGLUtil.cxx:3237
 TGLUtil.cxx:3238
 TGLUtil.cxx:3239
 TGLUtil.cxx:3240
 TGLUtil.cxx:3241
 TGLUtil.cxx:3242
 TGLUtil.cxx:3243
 TGLUtil.cxx:3244
 TGLUtil.cxx:3245
 TGLUtil.cxx:3246
 TGLUtil.cxx:3247
 TGLUtil.cxx:3248
 TGLUtil.cxx:3249
 TGLUtil.cxx:3250
 TGLUtil.cxx:3251
 TGLUtil.cxx:3252
 TGLUtil.cxx:3253
 TGLUtil.cxx:3254
 TGLUtil.cxx:3255
 TGLUtil.cxx:3256
 TGLUtil.cxx:3257
 TGLUtil.cxx:3258
 TGLUtil.cxx:3259
 TGLUtil.cxx:3260
 TGLUtil.cxx:3261
 TGLUtil.cxx:3262
 TGLUtil.cxx:3263
 TGLUtil.cxx:3264
 TGLUtil.cxx:3265
 TGLUtil.cxx:3266
 TGLUtil.cxx:3267
 TGLUtil.cxx:3268
 TGLUtil.cxx:3269
 TGLUtil.cxx:3270
 TGLUtil.cxx:3271
 TGLUtil.cxx:3272
 TGLUtil.cxx:3273
 TGLUtil.cxx:3274
 TGLUtil.cxx:3275
 TGLUtil.cxx:3276
 TGLUtil.cxx:3277
 TGLUtil.cxx:3278
 TGLUtil.cxx:3279
 TGLUtil.cxx:3280
 TGLUtil.cxx:3281
 TGLUtil.cxx:3282
 TGLUtil.cxx:3283
 TGLUtil.cxx:3284
 TGLUtil.cxx:3285
 TGLUtil.cxx:3286
 TGLUtil.cxx:3287
 TGLUtil.cxx:3288
 TGLUtil.cxx:3289
 TGLUtil.cxx:3290
 TGLUtil.cxx:3291
 TGLUtil.cxx:3292
 TGLUtil.cxx:3293
 TGLUtil.cxx:3294
 TGLUtil.cxx:3295
 TGLUtil.cxx:3296
 TGLUtil.cxx:3297
 TGLUtil.cxx:3298
 TGLUtil.cxx:3299
 TGLUtil.cxx:3300
 TGLUtil.cxx:3301
 TGLUtil.cxx:3302
 TGLUtil.cxx:3303
 TGLUtil.cxx:3304
 TGLUtil.cxx:3305
 TGLUtil.cxx:3306
 TGLUtil.cxx:3307
 TGLUtil.cxx:3308
 TGLUtil.cxx:3309
 TGLUtil.cxx:3310
 TGLUtil.cxx:3311
 TGLUtil.cxx:3312
 TGLUtil.cxx:3313
 TGLUtil.cxx:3314
 TGLUtil.cxx:3315
 TGLUtil.cxx:3316
 TGLUtil.cxx:3317
 TGLUtil.cxx:3318
 TGLUtil.cxx:3319
 TGLUtil.cxx:3320
 TGLUtil.cxx:3321
 TGLUtil.cxx:3322
 TGLUtil.cxx:3323
 TGLUtil.cxx:3324
 TGLUtil.cxx:3325
 TGLUtil.cxx:3326
 TGLUtil.cxx:3327
 TGLUtil.cxx:3328
 TGLUtil.cxx:3329
 TGLUtil.cxx:3330
 TGLUtil.cxx:3331
 TGLUtil.cxx:3332
 TGLUtil.cxx:3333
 TGLUtil.cxx:3334
 TGLUtil.cxx:3335
 TGLUtil.cxx:3336
 TGLUtil.cxx:3337
 TGLUtil.cxx:3338
 TGLUtil.cxx:3339
 TGLUtil.cxx:3340
 TGLUtil.cxx:3341
 TGLUtil.cxx:3342
 TGLUtil.cxx:3343
 TGLUtil.cxx:3344
 TGLUtil.cxx:3345
 TGLUtil.cxx:3346
 TGLUtil.cxx:3347
 TGLUtil.cxx:3348
 TGLUtil.cxx:3349
 TGLUtil.cxx:3350
 TGLUtil.cxx:3351
 TGLUtil.cxx:3352
 TGLUtil.cxx:3353
 TGLUtil.cxx:3354
 TGLUtil.cxx:3355
 TGLUtil.cxx:3356
 TGLUtil.cxx:3357
 TGLUtil.cxx:3358
 TGLUtil.cxx:3359
 TGLUtil.cxx:3360
 TGLUtil.cxx:3361
 TGLUtil.cxx:3362
 TGLUtil.cxx:3363
 TGLUtil.cxx:3364
 TGLUtil.cxx:3365
 TGLUtil.cxx:3366
 TGLUtil.cxx:3367
 TGLUtil.cxx:3368
 TGLUtil.cxx:3369
 TGLUtil.cxx:3370
 TGLUtil.cxx:3371
 TGLUtil.cxx:3372
 TGLUtil.cxx:3373
 TGLUtil.cxx:3374
 TGLUtil.cxx:3375
 TGLUtil.cxx:3376
 TGLUtil.cxx:3377
 TGLUtil.cxx:3378
 TGLUtil.cxx:3379
 TGLUtil.cxx:3380
 TGLUtil.cxx:3381
 TGLUtil.cxx:3382
 TGLUtil.cxx:3383
 TGLUtil.cxx:3384
 TGLUtil.cxx:3385
 TGLUtil.cxx:3386
 TGLUtil.cxx:3387
 TGLUtil.cxx:3388
 TGLUtil.cxx:3389
 TGLUtil.cxx:3390
 TGLUtil.cxx:3391
 TGLUtil.cxx:3392
 TGLUtil.cxx:3393
 TGLUtil.cxx:3394
 TGLUtil.cxx:3395
 TGLUtil.cxx:3396
 TGLUtil.cxx:3397
 TGLUtil.cxx:3398
 TGLUtil.cxx:3399
 TGLUtil.cxx:3400
 TGLUtil.cxx:3401
 TGLUtil.cxx:3402
 TGLUtil.cxx:3403
 TGLUtil.cxx:3404
 TGLUtil.cxx:3405
 TGLUtil.cxx:3406
 TGLUtil.cxx:3407
 TGLUtil.cxx:3408
 TGLUtil.cxx:3409
 TGLUtil.cxx:3410
 TGLUtil.cxx:3411
 TGLUtil.cxx:3412
 TGLUtil.cxx:3413
 TGLUtil.cxx:3414
 TGLUtil.cxx:3415
 TGLUtil.cxx:3416
 TGLUtil.cxx:3417
 TGLUtil.cxx:3418
 TGLUtil.cxx:3419
 TGLUtil.cxx:3420
 TGLUtil.cxx:3421
 TGLUtil.cxx:3422
 TGLUtil.cxx:3423
 TGLUtil.cxx:3424
 TGLUtil.cxx:3425
 TGLUtil.cxx:3426
 TGLUtil.cxx:3427
 TGLUtil.cxx:3428
 TGLUtil.cxx:3429
 TGLUtil.cxx:3430
 TGLUtil.cxx:3431
 TGLUtil.cxx:3432
 TGLUtil.cxx:3433
 TGLUtil.cxx:3434
 TGLUtil.cxx:3435
 TGLUtil.cxx:3436
 TGLUtil.cxx:3437
 TGLUtil.cxx:3438
 TGLUtil.cxx:3439
 TGLUtil.cxx:3440
 TGLUtil.cxx:3441
 TGLUtil.cxx:3442
 TGLUtil.cxx:3443
 TGLUtil.cxx:3444
 TGLUtil.cxx:3445
 TGLUtil.cxx:3446
 TGLUtil.cxx:3447
 TGLUtil.cxx:3448
 TGLUtil.cxx:3449
 TGLUtil.cxx:3450
 TGLUtil.cxx:3451
 TGLUtil.cxx:3452
 TGLUtil.cxx:3453
 TGLUtil.cxx:3454
 TGLUtil.cxx:3455
 TGLUtil.cxx:3456
 TGLUtil.cxx:3457
 TGLUtil.cxx:3458
 TGLUtil.cxx:3459
 TGLUtil.cxx:3460
 TGLUtil.cxx:3461
 TGLUtil.cxx:3462
 TGLUtil.cxx:3463
 TGLUtil.cxx:3464
 TGLUtil.cxx:3465
 TGLUtil.cxx:3466
 TGLUtil.cxx:3467
 TGLUtil.cxx:3468
 TGLUtil.cxx:3469
 TGLUtil.cxx:3470
 TGLUtil.cxx:3471
 TGLUtil.cxx:3472
 TGLUtil.cxx:3473
 TGLUtil.cxx:3474
 TGLUtil.cxx:3475
 TGLUtil.cxx:3476
 TGLUtil.cxx:3477
 TGLUtil.cxx:3478
 TGLUtil.cxx:3479
 TGLUtil.cxx:3480
 TGLUtil.cxx:3481
 TGLUtil.cxx:3482
 TGLUtil.cxx:3483
 TGLUtil.cxx:3484
 TGLUtil.cxx:3485
 TGLUtil.cxx:3486
 TGLUtil.cxx:3487
 TGLUtil.cxx:3488
 TGLUtil.cxx:3489
 TGLUtil.cxx:3490
 TGLUtil.cxx:3491
 TGLUtil.cxx:3492
 TGLUtil.cxx:3493
 TGLUtil.cxx:3494
 TGLUtil.cxx:3495
 TGLUtil.cxx:3496
 TGLUtil.cxx:3497
 TGLUtil.cxx:3498
 TGLUtil.cxx:3499
 TGLUtil.cxx:3500
 TGLUtil.cxx:3501
 TGLUtil.cxx:3502
 TGLUtil.cxx:3503
 TGLUtil.cxx:3504
 TGLUtil.cxx:3505
 TGLUtil.cxx:3506
 TGLUtil.cxx:3507
 TGLUtil.cxx:3508
 TGLUtil.cxx:3509
 TGLUtil.cxx:3510
 TGLUtil.cxx:3511
 TGLUtil.cxx:3512
 TGLUtil.cxx:3513
 TGLUtil.cxx:3514
 TGLUtil.cxx:3515
 TGLUtil.cxx:3516
 TGLUtil.cxx:3517
 TGLUtil.cxx:3518
 TGLUtil.cxx:3519
 TGLUtil.cxx:3520
 TGLUtil.cxx:3521
 TGLUtil.cxx:3522
 TGLUtil.cxx:3523
 TGLUtil.cxx:3524
 TGLUtil.cxx:3525
 TGLUtil.cxx:3526
 TGLUtil.cxx:3527
 TGLUtil.cxx:3528
 TGLUtil.cxx:3529
 TGLUtil.cxx:3530
 TGLUtil.cxx:3531
 TGLUtil.cxx:3532
 TGLUtil.cxx:3533
 TGLUtil.cxx:3534
 TGLUtil.cxx:3535
 TGLUtil.cxx:3536
 TGLUtil.cxx:3537
 TGLUtil.cxx:3538
 TGLUtil.cxx:3539
 TGLUtil.cxx:3540
 TGLUtil.cxx:3541
 TGLUtil.cxx:3542
 TGLUtil.cxx:3543
 TGLUtil.cxx:3544
 TGLUtil.cxx:3545
 TGLUtil.cxx:3546
 TGLUtil.cxx:3547
 TGLUtil.cxx:3548
 TGLUtil.cxx:3549
 TGLUtil.cxx:3550
 TGLUtil.cxx:3551
 TGLUtil.cxx:3552
 TGLUtil.cxx:3553
 TGLUtil.cxx:3554
 TGLUtil.cxx:3555
 TGLUtil.cxx:3556
 TGLUtil.cxx:3557
 TGLUtil.cxx:3558
 TGLUtil.cxx:3559
 TGLUtil.cxx:3560
 TGLUtil.cxx:3561
 TGLUtil.cxx:3562
 TGLUtil.cxx:3563
 TGLUtil.cxx:3564
 TGLUtil.cxx:3565
 TGLUtil.cxx:3566
 TGLUtil.cxx:3567
 TGLUtil.cxx:3568
 TGLUtil.cxx:3569
 TGLUtil.cxx:3570
 TGLUtil.cxx:3571
 TGLUtil.cxx:3572
 TGLUtil.cxx:3573
 TGLUtil.cxx:3574
 TGLUtil.cxx:3575
 TGLUtil.cxx:3576
 TGLUtil.cxx:3577
 TGLUtil.cxx:3578
 TGLUtil.cxx:3579
 TGLUtil.cxx:3580
 TGLUtil.cxx:3581
 TGLUtil.cxx:3582
 TGLUtil.cxx:3583
 TGLUtil.cxx:3584
 TGLUtil.cxx:3585
 TGLUtil.cxx:3586
 TGLUtil.cxx:3587
 TGLUtil.cxx:3588
 TGLUtil.cxx:3589
 TGLUtil.cxx:3590
 TGLUtil.cxx:3591
 TGLUtil.cxx:3592
 TGLUtil.cxx:3593
 TGLUtil.cxx:3594
 TGLUtil.cxx:3595
 TGLUtil.cxx:3596
 TGLUtil.cxx:3597
 TGLUtil.cxx:3598
 TGLUtil.cxx:3599
 TGLUtil.cxx:3600
 TGLUtil.cxx:3601
 TGLUtil.cxx:3602
 TGLUtil.cxx:3603
 TGLUtil.cxx:3604
 TGLUtil.cxx:3605
 TGLUtil.cxx:3606
 TGLUtil.cxx:3607
 TGLUtil.cxx:3608
 TGLUtil.cxx:3609
 TGLUtil.cxx:3610
 TGLUtil.cxx:3611
 TGLUtil.cxx:3612
 TGLUtil.cxx:3613
 TGLUtil.cxx:3614
 TGLUtil.cxx:3615
 TGLUtil.cxx:3616
 TGLUtil.cxx:3617
 TGLUtil.cxx:3618
 TGLUtil.cxx:3619
 TGLUtil.cxx:3620
 TGLUtil.cxx:3621
 TGLUtil.cxx:3622
 TGLUtil.cxx:3623
 TGLUtil.cxx:3624
 TGLUtil.cxx:3625
 TGLUtil.cxx:3626
 TGLUtil.cxx:3627
 TGLUtil.cxx:3628
 TGLUtil.cxx:3629
 TGLUtil.cxx:3630
 TGLUtil.cxx:3631
 TGLUtil.cxx:3632
 TGLUtil.cxx:3633
 TGLUtil.cxx:3634
 TGLUtil.cxx:3635
 TGLUtil.cxx:3636
 TGLUtil.cxx:3637
 TGLUtil.cxx:3638
 TGLUtil.cxx:3639
 TGLUtil.cxx:3640
 TGLUtil.cxx:3641
 TGLUtil.cxx:3642
 TGLUtil.cxx:3643
 TGLUtil.cxx:3644
 TGLUtil.cxx:3645
 TGLUtil.cxx:3646
 TGLUtil.cxx:3647
 TGLUtil.cxx:3648
 TGLUtil.cxx:3649
 TGLUtil.cxx:3650
 TGLUtil.cxx:3651
 TGLUtil.cxx:3652
 TGLUtil.cxx:3653
 TGLUtil.cxx:3654
 TGLUtil.cxx:3655
 TGLUtil.cxx:3656
 TGLUtil.cxx:3657
 TGLUtil.cxx:3658
 TGLUtil.cxx:3659
 TGLUtil.cxx:3660
 TGLUtil.cxx:3661
 TGLUtil.cxx:3662
 TGLUtil.cxx:3663
 TGLUtil.cxx:3664
 TGLUtil.cxx:3665
 TGLUtil.cxx:3666
 TGLUtil.cxx:3667
 TGLUtil.cxx:3668
 TGLUtil.cxx:3669
 TGLUtil.cxx:3670
 TGLUtil.cxx:3671
 TGLUtil.cxx:3672
 TGLUtil.cxx:3673
 TGLUtil.cxx:3674
 TGLUtil.cxx:3675
 TGLUtil.cxx:3676
 TGLUtil.cxx:3677
 TGLUtil.cxx:3678
 TGLUtil.cxx:3679
 TGLUtil.cxx:3680
 TGLUtil.cxx:3681
 TGLUtil.cxx:3682
 TGLUtil.cxx:3683
 TGLUtil.cxx:3684
 TGLUtil.cxx:3685
 TGLUtil.cxx:3686
 TGLUtil.cxx:3687
 TGLUtil.cxx:3688
 TGLUtil.cxx:3689
 TGLUtil.cxx:3690
 TGLUtil.cxx:3691
 TGLUtil.cxx:3692
 TGLUtil.cxx:3693
 TGLUtil.cxx:3694
 TGLUtil.cxx:3695
 TGLUtil.cxx:3696
 TGLUtil.cxx:3697
 TGLUtil.cxx:3698
 TGLUtil.cxx:3699
 TGLUtil.cxx:3700
 TGLUtil.cxx:3701
 TGLUtil.cxx:3702
 TGLUtil.cxx:3703
 TGLUtil.cxx:3704
 TGLUtil.cxx:3705
 TGLUtil.cxx:3706
 TGLUtil.cxx:3707
 TGLUtil.cxx:3708
 TGLUtil.cxx:3709
 TGLUtil.cxx:3710
 TGLUtil.cxx:3711
 TGLUtil.cxx:3712
 TGLUtil.cxx:3713
 TGLUtil.cxx:3714
 TGLUtil.cxx:3715
 TGLUtil.cxx:3716
 TGLUtil.cxx:3717
 TGLUtil.cxx:3718
 TGLUtil.cxx:3719
 TGLUtil.cxx:3720
 TGLUtil.cxx:3721
 TGLUtil.cxx:3722
 TGLUtil.cxx:3723
 TGLUtil.cxx:3724
 TGLUtil.cxx:3725
 TGLUtil.cxx:3726
 TGLUtil.cxx:3727
 TGLUtil.cxx:3728
 TGLUtil.cxx:3729
 TGLUtil.cxx:3730
 TGLUtil.cxx:3731
 TGLUtil.cxx:3732
 TGLUtil.cxx:3733
 TGLUtil.cxx:3734
 TGLUtil.cxx:3735
 TGLUtil.cxx:3736
 TGLUtil.cxx:3737
 TGLUtil.cxx:3738
 TGLUtil.cxx:3739
 TGLUtil.cxx:3740
 TGLUtil.cxx:3741
 TGLUtil.cxx:3742
 TGLUtil.cxx:3743
 TGLUtil.cxx:3744
 TGLUtil.cxx:3745
 TGLUtil.cxx:3746
 TGLUtil.cxx:3747
 TGLUtil.cxx:3748
 TGLUtil.cxx:3749
 TGLUtil.cxx:3750
 TGLUtil.cxx:3751
 TGLUtil.cxx:3752
 TGLUtil.cxx:3753
 TGLUtil.cxx:3754
 TGLUtil.cxx:3755
 TGLUtil.cxx:3756
 TGLUtil.cxx:3757
 TGLUtil.cxx:3758
 TGLUtil.cxx:3759
 TGLUtil.cxx:3760
 TGLUtil.cxx:3761
 TGLUtil.cxx:3762
 TGLUtil.cxx:3763
 TGLUtil.cxx:3764
 TGLUtil.cxx:3765
 TGLUtil.cxx:3766
 TGLUtil.cxx:3767
 TGLUtil.cxx:3768
 TGLUtil.cxx:3769
 TGLUtil.cxx:3770
 TGLUtil.cxx:3771
 TGLUtil.cxx:3772
 TGLUtil.cxx:3773
 TGLUtil.cxx:3774
 TGLUtil.cxx:3775
 TGLUtil.cxx:3776
 TGLUtil.cxx:3777
 TGLUtil.cxx:3778
 TGLUtil.cxx:3779
 TGLUtil.cxx:3780
 TGLUtil.cxx:3781
 TGLUtil.cxx:3782
 TGLUtil.cxx:3783
 TGLUtil.cxx:3784
 TGLUtil.cxx:3785
 TGLUtil.cxx:3786
 TGLUtil.cxx:3787
 TGLUtil.cxx:3788
 TGLUtil.cxx:3789
 TGLUtil.cxx:3790
 TGLUtil.cxx:3791
 TGLUtil.cxx:3792
 TGLUtil.cxx:3793
 TGLUtil.cxx:3794
 TGLUtil.cxx:3795
 TGLUtil.cxx:3796
 TGLUtil.cxx:3797
 TGLUtil.cxx:3798
 TGLUtil.cxx:3799
 TGLUtil.cxx:3800
 TGLUtil.cxx:3801
 TGLUtil.cxx:3802
 TGLUtil.cxx:3803
 TGLUtil.cxx:3804
 TGLUtil.cxx:3805
 TGLUtil.cxx:3806
 TGLUtil.cxx:3807
 TGLUtil.cxx:3808
 TGLUtil.cxx:3809
 TGLUtil.cxx:3810
 TGLUtil.cxx:3811
 TGLUtil.cxx:3812
 TGLUtil.cxx:3813
 TGLUtil.cxx:3814
 TGLUtil.cxx:3815
 TGLUtil.cxx:3816
 TGLUtil.cxx:3817
 TGLUtil.cxx:3818
 TGLUtil.cxx:3819
 TGLUtil.cxx:3820
 TGLUtil.cxx:3821
 TGLUtil.cxx:3822
 TGLUtil.cxx:3823
 TGLUtil.cxx:3824
 TGLUtil.cxx:3825
 TGLUtil.cxx:3826
 TGLUtil.cxx:3827
 TGLUtil.cxx:3828
 TGLUtil.cxx:3829
 TGLUtil.cxx:3830
 TGLUtil.cxx:3831
 TGLUtil.cxx:3832
 TGLUtil.cxx:3833
 TGLUtil.cxx:3834
 TGLUtil.cxx:3835
 TGLUtil.cxx:3836
 TGLUtil.cxx:3837
 TGLUtil.cxx:3838
 TGLUtil.cxx:3839
 TGLUtil.cxx:3840
 TGLUtil.cxx:3841
 TGLUtil.cxx:3842
 TGLUtil.cxx:3843
 TGLUtil.cxx:3844
 TGLUtil.cxx:3845
 TGLUtil.cxx:3846
 TGLUtil.cxx:3847
 TGLUtil.cxx:3848
 TGLUtil.cxx:3849
 TGLUtil.cxx:3850
 TGLUtil.cxx:3851
 TGLUtil.cxx:3852
 TGLUtil.cxx:3853
 TGLUtil.cxx:3854
 TGLUtil.cxx:3855
 TGLUtil.cxx:3856
 TGLUtil.cxx:3857
 TGLUtil.cxx:3858
 TGLUtil.cxx:3859
 TGLUtil.cxx:3860
 TGLUtil.cxx:3861
 TGLUtil.cxx:3862
 TGLUtil.cxx:3863
 TGLUtil.cxx:3864
 TGLUtil.cxx:3865
 TGLUtil.cxx:3866
 TGLUtil.cxx:3867
 TGLUtil.cxx:3868
 TGLUtil.cxx:3869
 TGLUtil.cxx:3870
 TGLUtil.cxx:3871
 TGLUtil.cxx:3872
 TGLUtil.cxx:3873
 TGLUtil.cxx:3874
 TGLUtil.cxx:3875
 TGLUtil.cxx:3876
 TGLUtil.cxx:3877
 TGLUtil.cxx:3878
 TGLUtil.cxx:3879
 TGLUtil.cxx:3880
 TGLUtil.cxx:3881
 TGLUtil.cxx:3882
 TGLUtil.cxx:3883
 TGLUtil.cxx:3884
 TGLUtil.cxx:3885
 TGLUtil.cxx:3886
 TGLUtil.cxx:3887
 TGLUtil.cxx:3888
 TGLUtil.cxx:3889
 TGLUtil.cxx:3890
 TGLUtil.cxx:3891
 TGLUtil.cxx:3892
 TGLUtil.cxx:3893
 TGLUtil.cxx:3894
 TGLUtil.cxx:3895
 TGLUtil.cxx:3896
 TGLUtil.cxx:3897
 TGLUtil.cxx:3898
 TGLUtil.cxx:3899
 TGLUtil.cxx:3900
 TGLUtil.cxx:3901
 TGLUtil.cxx:3902
 TGLUtil.cxx:3903
 TGLUtil.cxx:3904
 TGLUtil.cxx:3905
 TGLUtil.cxx:3906
 TGLUtil.cxx:3907
 TGLUtil.cxx:3908
 TGLUtil.cxx:3909
 TGLUtil.cxx:3910
 TGLUtil.cxx:3911
 TGLUtil.cxx:3912
 TGLUtil.cxx:3913
 TGLUtil.cxx:3914
 TGLUtil.cxx:3915
 TGLUtil.cxx:3916
 TGLUtil.cxx:3917
 TGLUtil.cxx:3918
 TGLUtil.cxx:3919
 TGLUtil.cxx:3920
 TGLUtil.cxx:3921
 TGLUtil.cxx:3922
 TGLUtil.cxx:3923
 TGLUtil.cxx:3924
 TGLUtil.cxx:3925
 TGLUtil.cxx:3926
 TGLUtil.cxx:3927
 TGLUtil.cxx:3928
 TGLUtil.cxx:3929
 TGLUtil.cxx:3930
 TGLUtil.cxx:3931
 TGLUtil.cxx:3932
 TGLUtil.cxx:3933
 TGLUtil.cxx:3934
 TGLUtil.cxx:3935
 TGLUtil.cxx:3936
 TGLUtil.cxx:3937
 TGLUtil.cxx:3938
 TGLUtil.cxx:3939
 TGLUtil.cxx:3940
 TGLUtil.cxx:3941
 TGLUtil.cxx:3942
 TGLUtil.cxx:3943
 TGLUtil.cxx:3944
 TGLUtil.cxx:3945
 TGLUtil.cxx:3946
 TGLUtil.cxx:3947
 TGLUtil.cxx:3948
 TGLUtil.cxx:3949
 TGLUtil.cxx:3950
 TGLUtil.cxx:3951
 TGLUtil.cxx:3952
 TGLUtil.cxx:3953
 TGLUtil.cxx:3954
 TGLUtil.cxx:3955
 TGLUtil.cxx:3956
 TGLUtil.cxx:3957
 TGLUtil.cxx:3958
 TGLUtil.cxx:3959
 TGLUtil.cxx:3960
 TGLUtil.cxx:3961
 TGLUtil.cxx:3962
 TGLUtil.cxx:3963
 TGLUtil.cxx:3964
 TGLUtil.cxx:3965
 TGLUtil.cxx:3966
 TGLUtil.cxx:3967
 TGLUtil.cxx:3968
 TGLUtil.cxx:3969
 TGLUtil.cxx:3970
 TGLUtil.cxx:3971
 TGLUtil.cxx:3972
 TGLUtil.cxx:3973
 TGLUtil.cxx:3974
 TGLUtil.cxx:3975
 TGLUtil.cxx:3976
 TGLUtil.cxx:3977
 TGLUtil.cxx:3978
 TGLUtil.cxx:3979
 TGLUtil.cxx:3980
 TGLUtil.cxx:3981
 TGLUtil.cxx:3982
 TGLUtil.cxx:3983
 TGLUtil.cxx:3984
 TGLUtil.cxx:3985
 TGLUtil.cxx:3986
 TGLUtil.cxx:3987
 TGLUtil.cxx:3988
 TGLUtil.cxx:3989
 TGLUtil.cxx:3990
 TGLUtil.cxx:3991
 TGLUtil.cxx:3992
 TGLUtil.cxx:3993
 TGLUtil.cxx:3994
 TGLUtil.cxx:3995
 TGLUtil.cxx:3996
 TGLUtil.cxx:3997
 TGLUtil.cxx:3998
 TGLUtil.cxx:3999
 TGLUtil.cxx:4000
 TGLUtil.cxx:4001
 TGLUtil.cxx:4002
 TGLUtil.cxx:4003
 TGLUtil.cxx:4004
 TGLUtil.cxx:4005
 TGLUtil.cxx:4006
 TGLUtil.cxx:4007
 TGLUtil.cxx:4008
 TGLUtil.cxx:4009
 TGLUtil.cxx:4010
 TGLUtil.cxx:4011
 TGLUtil.cxx:4012
 TGLUtil.cxx:4013
 TGLUtil.cxx:4014
 TGLUtil.cxx:4015
 TGLUtil.cxx:4016
 TGLUtil.cxx:4017
 TGLUtil.cxx:4018
 TGLUtil.cxx:4019
 TGLUtil.cxx:4020
 TGLUtil.cxx:4021
 TGLUtil.cxx:4022
 TGLUtil.cxx:4023
 TGLUtil.cxx:4024
 TGLUtil.cxx:4025
 TGLUtil.cxx:4026
 TGLUtil.cxx:4027
 TGLUtil.cxx:4028
 TGLUtil.cxx:4029
 TGLUtil.cxx:4030
 TGLUtil.cxx:4031
 TGLUtil.cxx:4032
 TGLUtil.cxx:4033
 TGLUtil.cxx:4034
 TGLUtil.cxx:4035
 TGLUtil.cxx:4036
 TGLUtil.cxx:4037
 TGLUtil.cxx:4038
 TGLUtil.cxx:4039
 TGLUtil.cxx:4040
 TGLUtil.cxx:4041
 TGLUtil.cxx:4042
 TGLUtil.cxx:4043
 TGLUtil.cxx:4044
 TGLUtil.cxx:4045
 TGLUtil.cxx:4046
 TGLUtil.cxx:4047
 TGLUtil.cxx:4048
 TGLUtil.cxx:4049
 TGLUtil.cxx:4050
 TGLUtil.cxx:4051
 TGLUtil.cxx:4052
 TGLUtil.cxx:4053
 TGLUtil.cxx:4054
 TGLUtil.cxx:4055
 TGLUtil.cxx:4056
 TGLUtil.cxx:4057
 TGLUtil.cxx:4058
 TGLUtil.cxx:4059
 TGLUtil.cxx:4060
 TGLUtil.cxx:4061
 TGLUtil.cxx:4062
 TGLUtil.cxx:4063
 TGLUtil.cxx:4064
 TGLUtil.cxx:4065
 TGLUtil.cxx:4066
 TGLUtil.cxx:4067
 TGLUtil.cxx:4068
 TGLUtil.cxx:4069
 TGLUtil.cxx:4070
 TGLUtil.cxx:4071
 TGLUtil.cxx:4072
 TGLUtil.cxx:4073
 TGLUtil.cxx:4074
 TGLUtil.cxx:4075
 TGLUtil.cxx:4076
 TGLUtil.cxx:4077
 TGLUtil.cxx:4078
 TGLUtil.cxx:4079
 TGLUtil.cxx:4080
 TGLUtil.cxx:4081
 TGLUtil.cxx:4082
 TGLUtil.cxx:4083
 TGLUtil.cxx:4084
 TGLUtil.cxx:4085
 TGLUtil.cxx:4086
 TGLUtil.cxx:4087
 TGLUtil.cxx:4088
 TGLUtil.cxx:4089
 TGLUtil.cxx:4090
 TGLUtil.cxx:4091
 TGLUtil.cxx:4092
 TGLUtil.cxx:4093
 TGLUtil.cxx:4094
 TGLUtil.cxx:4095
 TGLUtil.cxx:4096
 TGLUtil.cxx:4097
 TGLUtil.cxx:4098
 TGLUtil.cxx:4099
 TGLUtil.cxx:4100
 TGLUtil.cxx:4101
 TGLUtil.cxx:4102
 TGLUtil.cxx:4103
 TGLUtil.cxx:4104
 TGLUtil.cxx:4105
 TGLUtil.cxx:4106
 TGLUtil.cxx:4107
 TGLUtil.cxx:4108
 TGLUtil.cxx:4109
 TGLUtil.cxx:4110
 TGLUtil.cxx:4111
 TGLUtil.cxx:4112
 TGLUtil.cxx:4113
 TGLUtil.cxx:4114
 TGLUtil.cxx:4115
 TGLUtil.cxx:4116
 TGLUtil.cxx:4117
 TGLUtil.cxx:4118
 TGLUtil.cxx:4119
 TGLUtil.cxx:4120
 TGLUtil.cxx:4121
 TGLUtil.cxx:4122
 TGLUtil.cxx:4123
 TGLUtil.cxx:4124
 TGLUtil.cxx:4125
 TGLUtil.cxx:4126
 TGLUtil.cxx:4127
 TGLUtil.cxx:4128
 TGLUtil.cxx:4129
 TGLUtil.cxx:4130
 TGLUtil.cxx:4131
 TGLUtil.cxx:4132
 TGLUtil.cxx:4133
 TGLUtil.cxx:4134
 TGLUtil.cxx:4135
 TGLUtil.cxx:4136
 TGLUtil.cxx:4137
 TGLUtil.cxx:4138
 TGLUtil.cxx:4139
 TGLUtil.cxx:4140
 TGLUtil.cxx:4141
 TGLUtil.cxx:4142
 TGLUtil.cxx:4143
 TGLUtil.cxx:4144
 TGLUtil.cxx:4145
 TGLUtil.cxx:4146
 TGLUtil.cxx:4147
 TGLUtil.cxx:4148
 TGLUtil.cxx:4149
 TGLUtil.cxx:4150
 TGLUtil.cxx:4151
 TGLUtil.cxx:4152
 TGLUtil.cxx:4153
 TGLUtil.cxx:4154
 TGLUtil.cxx:4155
 TGLUtil.cxx:4156
 TGLUtil.cxx:4157
 TGLUtil.cxx:4158
 TGLUtil.cxx:4159
 TGLUtil.cxx:4160
 TGLUtil.cxx:4161
 TGLUtil.cxx:4162
 TGLUtil.cxx:4163
 TGLUtil.cxx:4164
 TGLUtil.cxx:4165
 TGLUtil.cxx:4166
 TGLUtil.cxx:4167
 TGLUtil.cxx:4168
 TGLUtil.cxx:4169
 TGLUtil.cxx:4170
 TGLUtil.cxx:4171
 TGLUtil.cxx:4172
 TGLUtil.cxx:4173
 TGLUtil.cxx:4174
 TGLUtil.cxx:4175
 TGLUtil.cxx:4176
 TGLUtil.cxx:4177
 TGLUtil.cxx:4178
 TGLUtil.cxx:4179
 TGLUtil.cxx:4180
 TGLUtil.cxx:4181
 TGLUtil.cxx:4182
 TGLUtil.cxx:4183