#include "viewerdraw.h"

#include "tapp.h"

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/cleanupparameters.h"

#include "sceneviewer.h"

#include "ruler.h"

#include "tgl.h"

#include "trop.h"

#include "toonz/txsheet.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/tstageobjectid.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/stage2.h"

#include "toonz/tcamera.h"

#include "toonz/tproject.h"

#include "toonz/preferences.h"

#include "toonz/toonzfolders.h"

#include "toonzqt/gutil.h"

#include "tconvert.h"

#include "tenv.h"

#include "tsystem.h"

#include "tfilepath_io.h"

#include "tstream.h"

#include "subcameramanager.h"

#include <qsettings></qsettings>

TEnv::StringVar EnvSafeAreaName("SafeAreaName", "PR_safe");

/* TODO, move to include */

void getSafeAreaSizeList(QList<qlist<double>> &_sizeList);</qlist<double>

//=============================================================================

//=============================================================================

// SafeAreaData

//-----------------------------------------------------------------------------

void getSafeAreaSizeList(QList<qlist<double>> &_sizeList) {</qlist<double>

  static QList<qlist<double>> sizeList;</qlist<double>

  static TFilePath projectPath;

  static QString safeAreaName;

  TFilePath fp                = TEnv::getConfigDir();

  QString currentSafeAreaName = QString::fromStdString(EnvSafeAreaName);

  if (fp != projectPath || currentSafeAreaName != safeAreaName) {

    sizeList.clear();

    projectPath  = fp;

    safeAreaName = currentSafeAreaName;

    std::string safeAreaFileName = "safearea.ini";

    while (!TFileStatus(fp + safeAreaFileName).doesExist() && !fp.isRoot() &&

           fp.getParentDir() != TFilePath())

      fp = fp.getParentDir();

    fp = fp + safeAreaFileName;

    if (TFileStatus(fp).doesExist()) {

      QSettings settings(toQString(fp), QSettings::IniFormat);

      // find the current safearea name from the list

      QStringList groups = settings.childGroups();

      for (int g = 0; g < groups.size(); g++) {

        settings.beginGroup(groups.at(g));

        // If found, get the safe area setting values

        if (safeAreaName == settings.value("name", "").toString()) {

          // enter area group

          settings.beginGroup("area");

          QStringList keys = settings.childKeys();

          for (int i = 0; i < keys.size(); i++) {

            QList<qvariant> tmp =</qvariant>

                settings.value(keys.at(i), QList<qvariant>()).toList();</qvariant>

            QList<double> val_list;</double>

            for (int j = 0; j < tmp.size(); j++)

              val_list.push_back(tmp.at(j).toDouble());

            sizeList.push_back(val_list);

          }

          // close area group

          settings.endGroup();

          settings.endGroup();

          break;

        }

        settings.endGroup();

      }

      // If not found, then put some temporal values..

      if (sizeList.isEmpty()) {

        QList<double> tmpList0, tmpList1;</double>

        tmpList0 << 80.0 << 80.0;

        tmpList1 << 90.0 << 90.0;

        sizeList << tmpList0 << tmpList1;

      }

    }

  }

  _sizeList = sizeList;

}

//-----------------------------------------------------------------------------

namespace {

//-----------------------------------------------------------------------------

// da spostare in tgl.h?

inline void glVertex(const T3DPointD &p) { glVertex3d(p.x, p.y, p.z); }

//-----------------------------------------------------------------------------

// da spostare in util.h?

inline int findLowerIndex(double x, double step) {

  int index;

  double istep = 1 / step;

  if (x >= 0)

    index = tfloor(x * istep);

  else

    index = -tceil(-x * istep);

  assert(index * step <= x && x < (index + 1) * step);

  return index;

}

//-----------------------------------------------------------------------------

inline int findUpperIndex(double x, double step) {

  int index = -findLowerIndex(-x, step);

  assert((index - 1) * step < x && x <= index * step);

  return index;

}

//-----------------------------------------------------------------------------

T3DPointD make3dPoint(const TPointD &p, double z) {

  return T3DPointD(p.x, p.y, z);

}

//-----------------------------------------------------------------------------

/*

void getCameraSection(T3DPointD points[4], int row, double z)

{

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();

  double camZ = xsh->getZ(cameraId, row);

  TAffine camAff = xsh->getPlacement(cameraId, row);

  TRectD cameraRect =

    TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera()->getStageRect();

  TPointD p[4];

  p[0] = camAff * cameraRect.getP00();

  p[1] = camAff * cameraRect.getP10();

  p[2] = camAff * cameraRect.getP11();

  p[3] = camAff * cameraRect.getP01();

  TPointD center = 0.5*(p[0]+p[2]);

  double f = 1000;

  double sc = 1+(camZ-z)/f;

  for(int i=0;i<4;i++)

    points[i] = make3dPoint(center+sc*(p[i]-center), z);

}

*/

//-----------------------------------------------------------------------------

}  // namespace

//=============================================================================

//=============================================================================

// ViewerDraw

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

/*! when camera view mode, draw the mask plane outside of the camera box

*/

void ViewerDraw::drawCameraMask(SceneViewer *viewer) {

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  //  TAffine viewMatrix = viewer->getViewMatrix();

  int x1, x2, y1, y2;

  viewer->rect().getCoords(&x1, &y1, &x2, &y2);

  TRect clipRect = TRect(x1, y1, x2 + 1, y2 + 1);

  GLfloat modelView[16];

  glGetFloatv(GL_MODELVIEW_MATRIX, modelView);

  TAffine modelViewAff(modelView[0], modelView[4], modelView[12], modelView[1],

                       modelView[5], modelView[13]);

  TRectD cameraRect = getCameraRect();

  TPointD clipCorner[] = {

      modelViewAff.inv() * TPointD(clipRect.x0, clipRect.y0),

      modelViewAff.inv() * TPointD(clipRect.x1, clipRect.y0),

      modelViewAff.inv() * TPointD(clipRect.x1, clipRect.y1),

      modelViewAff.inv() * TPointD(clipRect.x0, clipRect.y1)};

  // bounds: nel sistema di riferimento "corrente" bounds e' il piu' piccolo

  // rettangolo che copre completamente tutto il viewer

  TRectD bounds;

  bounds.x0 = bounds.x1 = clipCorner[0].x;

  bounds.y0 = bounds.y1 = clipCorner[0].y;

  int i;

  for (i = 1; i < 4; i++) {

    const TPointD &p = clipCorner[i];

    if (p.x < bounds.x0)

      bounds.x0 = p.x;

    else if (p.x > bounds.x1)

      bounds.x1 = p.x;

    if (p.y < bounds.y0)

      bounds.y0 = p.y;

    else if (p.y > bounds.y1)

      bounds.y1 = p.y;

  }

  // set the camera mask color same as the previewBG color

  TPixel32 maskColor = Preferences::instance()->getPreviewBgColor();

  double mask_r, mask_g, mask_b;

  mask_r = (double)maskColor.r / 255.0;

  mask_g = (double)maskColor.g / 255.0;

  mask_b = (double)maskColor.b / 255.0;

  glColor3d(mask_r, mask_g, mask_b);

  if (cameraRect.overlaps(bounds)) {

    double x0 = cameraRect.x0;

    double y0 = cameraRect.y0;

    double x1 = cameraRect.x1;

    double y1 = cameraRect.y1;

    if (bounds.x0 <= x0) tglFillRect(bounds.x0, bounds.y0, x0, bounds.y1);

    if (x1 <= bounds.x1) tglFillRect(x1, bounds.y0, bounds.x1, bounds.y1);

    if (x0 < bounds.x1 && x1 > bounds.x0) {

      double xa = std::max(x0, bounds.x0);

      double xb = std::min(x1, bounds.x1);

      if (bounds.y0 < y0) tglFillRect(xa, bounds.y0, xb, y0);

      if (y1 < bounds.y1) tglFillRect(xa, y1, xb, bounds.y1);

    }

  } else {

    tglFillRect(bounds);

  }

}

//-----------------------------------------------------------------------------

void ViewerDraw::drawGridAndGuides(SceneViewer *viewer, double sc, Ruler *vr,

                                   Ruler *hr, bool gridEnabled) {

  int vGuideCount     = 0;

  int hGuideCount     = 0;

  if (vr) vGuideCount = vr->getGuideCount();

  if (hr) hGuideCount = hr->getGuideCount();

  // int xp1, yp1, xp2, yp2;

  // viewer->geometry().getCoords(&xp1, &yp1, &xp2, &yp2);

  TRect clipRect = TRect(-20, -10, viewer->width() + 10, viewer->height() + 20);

  // TRect clipRect = TRect(xp1- 20, yp2 + 20, xp2 + 10, yp1 - 10);

  // viewer->rect().adjusted(-20, -10, 10, 20);

  clipRect -=

      TPoint((clipRect.x0 + clipRect.x1) / 2, (clipRect.y0 + clipRect.y1) / 2);

  TAffine mat = viewer->getViewMatrix().inv();

  TPointD p00 = mat * convert(clipRect.getP00());

  TPointD p01 = mat * convert(clipRect.getP01());

  TPointD p10 = mat * convert(clipRect.getP10());

  TPointD p11 = mat * convert(clipRect.getP11());

  double xmin = std::min({p00.x, p01.x, p10.x, p11.x});

  double xmax = std::max({p00.x, p01.x, p10.x, p11.x});

  double ymin = std::min({p00.y, p01.y, p10.y, p11.y});

  double ymax = std::max({p00.y, p01.y, p10.y, p11.y});

  double step  = 10;

  double absSc = std::abs(sc);

  if (absSc * step < 4)

    while (absSc * step < 4) step *= 5;

  else if (absSc * step > 20)

    while (absSc * step > 20) step *= 0.2;

  int i0 = findLowerIndex(xmin, step);

  int i1 = findUpperIndex(xmax, step);

  int j0 = findLowerIndex(ymin, step);

  int j1 = findUpperIndex(ymax, step);

  double x0 = i0 * step;

  double x1 = i1 * step;

  double y0 = j0 * step;

  double y1 = j1 * step;

  if (gridEnabled) {

    glColor3d(0.7, 0.7, 0.7);

    glBegin(GL_LINES);

    glVertex2d(0, y0);

    glVertex2d(0, y1);

    glVertex2d(x0, 0);

    glVertex2d(x1, 0);

    glEnd();

    glEnable(GL_LINE_STIPPLE);

    glLineStipple(1, 0xAAAA);

    glBegin(GL_LINES);

    int i;

    for (i = i0; i <= i1; i++) {

      double x = i * step;

      if (i == 0)

        continue;

      else if ((abs(i) % 10) == 0)

        glColor3d(0.8, 0.8, 0.8);

      else

        glColor3d(0.9, 0.9, 0.9);

      glVertex2d(x, y0);

      glVertex2d(x, y1);

    }

    for (i = j0; i <= j1; i++) {

      double y = i * step;

      if (i == 0)

        continue;

      else if ((abs(i) % 10) == 0)

        glColor3d(0.8, 0.8, 0.8);

      else

        glColor3d(0.9, 0.9, 0.9);

      glVertex2d(x0, y);

      glVertex2d(x1, y);

    }

    glEnd();

    glDisable(GL_LINE_STIPPLE);

  }

  glColor3d(0.7, 0.7, 0.7);

  glLineStipple(1, 0xAAAA);

  glEnable(GL_LINE_STIPPLE);

  int i;

  glBegin(GL_LINES);

  for (i = 0; i < hGuideCount; i++) {

    double x = hr->getGuide(i);

    glVertex2d(x, y0);

    glVertex2d(x, y1);

  }

  for (i = 0; i < vGuideCount; i++) {

    double y = vr->getGuide(i);

    glVertex2d(x0, y);

    glVertex2d(x1, y);

  }

  glEnd();

  glDisable(GL_LINE_STIPPLE);

}

//-----------------------------------------------------------------------------

void ViewerDraw::drawColorcard(UCHAR channel) {

  ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();

  TRectD rect       = getCameraRect();

  TPixel color = (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)

                     ? TPixel::Black

                     : scene->getProperties()->getBgColor();

  if (channel == 0)

    color.m = 255;  // fondamentale: senno' non si vedono i fill con le texture

                    // in camera stand!

  else {

    if (channel == TRop::MChan) {

      switch (channel) {

      case TRop::RChan:

        color.r = color.g = color.b = color.m = color.r;

        break;

      case TRop::GChan:

        color.r = color.g = color.b = color.m = color.g;

        break;

      case TRop::BChan:

        color.r = color.g = color.b = color.m = color.b;

        break;

      case TRop::MChan:

        color.r = color.g = color.b = color.m = color.m;

        break;

      default:

        assert(false);

      }

    } else {

      color.r = channel & TRop::RChan ? color.r : 0;

      color.b = channel & TRop::BChan ? color.b : 0;

      color.g = channel & TRop::GChan ? color.g : 0;

    }

  }

  tglColor(color);

  tglFillRect(rect);

}

//-----------------------------------------------------------------------------

void ViewerDraw::draw3DCamera(unsigned long flags, double zmin, double phi) {

  bool cameraRef = 0 != (flags & ViewerDraw::CAMERA_REFERENCE);

  bool safeArea  = 0 != (flags & ViewerDraw::SAFE_AREA);

  TApp *app               = TApp::instance();

  int frame               = app->getCurrentFrame()->getFrame();

  ToonzScene *scene       = app->getCurrentScene()->getScene();

  TXsheet *xsh            = scene->getXsheet();

  TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();

  TAffine camAff          = xsh->getPlacement(cameraId, frame);

  double zcam             = xsh->getZ(cameraId, frame);

  TRectD rect             = getCameraRect();

  double znear = 1000 + zcam - 100;

  TPointD cameraCorners[4] = {camAff * rect.getP00(), camAff * rect.getP10(),

                              camAff * rect.getP11(), camAff * rect.getP01()};

  TPointD cameraCenter = 0.5 * (cameraCorners[0] + cameraCorners[2]);

  T3DPointD cage[4][4];

  std::vector<double> cageZ;</double>

  cageZ.push_back(znear);

  double ztable = 0;

  if (ztable < znear) cageZ.push_back(ztable);

  if (zmin < znear) cageZ.push_back(zmin);

  int columnIndex = app->getCurrentColumn()->getColumnIndex();

  if (columnIndex >= 0) {

    TStageObjectId objId = TStageObjectId::ColumnId(columnIndex);

    double zcur          = xsh->getZ(objId, frame);

    if (zcur < znear) cageZ.push_back(zcur);

  }

  std::sort(cageZ.begin(), cageZ.end());

  int m = (int)cageZ.size();

  for (int i = 0; i < m; i++) {

    double z  = cageZ[i];

    double sc = (1000 + zcam - z) * 0.001;

    for (int j = 0; j < 4; j++)

      cage[i][j] =

          make3dPoint(cameraCenter + sc * (cameraCorners[j] - cameraCenter), z);

  }

  if (cameraRef) {

    glColor3d(1.0, 0.0, 1.0);

    glLineStipple(1, 0xFFFC);

  } else {

    glColor3d(1.0, 0.0, 0.0);

    glLineStipple(1, 0xCCCC);

  }

  glEnable(GL_LINE_STIPPLE);

  double yBigBox       = -Stage::bigBoxSize[1];

  double xBigBox       = Stage::bigBoxSize[0];

  if (phi < 0) xBigBox = -xBigBox;

  for (int i = 0; i < m; i++) {

    // ombre

    glColor3d(1.0, 0.8, 0.8);

    glBegin(GL_LINES);

    glVertex3d(cage[i][0].x, yBigBox, cageZ[i]);

    glVertex3d(cage[i][1].x, yBigBox, cageZ[i]);

    glVertex3d(xBigBox, cage[i][1].y, cageZ[i]);

    glVertex3d(xBigBox, cage[i][2].y, cageZ[i]);

    glEnd();

    glColor3d(1.0, 0.0, 0.0);

    glBegin(GL_LINE_STRIP);

    for (int j = 0; j < 4; j++) glVertex(cage[i][j]);

    glVertex(cage[i][0]);

    glEnd();

  }

  if (m >= 2) {

    // ombre

    glColor3d(1.0, 0.8, 0.8);

    glVertex3d(cage[0][0].x, yBigBox, cageZ[0]);

    glVertex3d(cage[m - 1][0].x, yBigBox, cageZ[m - 1]);

    glVertex3d(cage[0][1].x, yBigBox, cageZ[0]);

    glVertex3d(cage[m - 1][1].x, yBigBox, cageZ[m - 1]);

    glVertex3d(xBigBox, cage[0][1].y, cageZ[0]);

    glVertex3d(xBigBox, cage[m - 1][1].y, cageZ[m - 1]);

    glVertex3d(xBigBox, cage[0][2].y, cageZ[0]);

    glVertex3d(xBigBox, cage[m - 1][2].y, cageZ[m - 1]);

    glColor3d(1.0, 0.0, 0.0);

    glBegin(GL_LINES);

    for (int j = 0; j < 4; j++) {

      glVertex(cage[0][j]);

      glVertex(cage[m - 1][j]);

    }

    glEnd();

  }

  /*

if(objId != cameraId)

{

glColor3d(1.0,0.0,1.0);

glBegin(GL_LINE_STRIP);

for(j=0;j<4;j++) glVertex(currentRect[j]);

glVertex(currentRect[0]);

glEnd();

}

*/

  glDisable(GL_LINE_STIPPLE);

  /*

glPushMatrix();

glTranslated(0,0,zcam);

drawCamera(flags);

glPopMatrix();

*/

}

//-----------------------------------------------------------------------------

TRectD ViewerDraw::getCameraRect() {

  if (CleanupPreviewCheck::instance()->isEnabled() ||

      CameraTestCheck::instance()->isEnabled())

    return TApp::instance()

        ->getCurrentScene()

        ->getScene()

        ->getProperties()

        ->getCleanupParameters()

        ->m_camera.getStageRect();

  else

    return TApp::instance()

        ->getCurrentScene()

        ->getScene()

        ->getCurrentCamera()

        ->getStageRect();

}

//-----------------------------------------------------------------------------

void ViewerDraw::drawSafeArea() {

  TRectD rect = getCameraRect();

  glColor3d(1.0, 0.0, 0.0);

  glLineStipple(1, 0xCCCC);

  glEnable(GL_LINE_STIPPLE);

  QList<qlist<double>> sizeList;</qlist<double>

  getSafeAreaSizeList(sizeList);

  double ux = 0.5 * rect.getLx();

  double uy = 0.5 * rect.getLy();

  for (int i = 0; i < sizeList.size(); i++) {

    QList<double> curSize = sizeList.at(i);</double>

    if (curSize.size() == 5)

      tglColor(

          TPixel((int)curSize.at(2), (int)curSize.at(3), (int)curSize.at(4)));

    else

      tglColor(TPixel32::Red);

    double fx = 0.01 * curSize.at(0);

    double fy = 0.01 * curSize.at(1);

    tglDrawRect(-ux * fx, -uy * fy, ux * fx, uy * fy);

  }

  glDisable(GL_LINE_STIPPLE);

}

//-----------------------------------------------------------------------------

void ViewerDraw::drawCamera(unsigned long flags, double pixelSize) {

  bool cameraRef = 0 != (flags & ViewerDraw::CAMERA_REFERENCE);

  bool camera3d  = 0 != (flags & ViewerDraw::CAMERA_3D);

  bool solidLine = 0 != (flags & ViewerDraw::SOLID_LINE);

  bool subcamera = 0 != (flags & ViewerDraw::SUBCAMERA);

  TApp *app               = TApp::instance();

  ToonzScene *scene       = app->getCurrentScene()->getScene();

  TXsheet *xsh            = scene->getXsheet();

  TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();

  TRectD rect = getCameraRect();

  if (cameraRef) {

    glColor3d(1.0, 0.0, 1.0);

    glLineStipple(1, 0xFFFC);

  } else {

    glColor3d(1.0, 0.0, 0.0);

    glLineStipple(1, solidLine ? 0xFFFF : 0xCCCC);

  }

  glEnable(GL_LINE_STIPPLE);

  // bordo

  glBegin(GL_LINE_STRIP);

  glVertex2d(rect.x0, rect.y0);

  glVertex2d(rect.x0, rect.y1 - pixelSize);

  glVertex2d(rect.x1 - pixelSize, rect.y1 - pixelSize);

  glVertex2d(rect.x1 - pixelSize, rect.y0);

  glVertex2d(rect.x0, rect.y0);

  glEnd();

  // croce al centro

  double dx = 0.05 * rect.getP00().x;

  double dy = 0.05 * rect.getP00().y;

  tglDrawSegment(TPointD(-dx, -dy), TPointD(dx, dy));

  tglDrawSegment(TPointD(-dx, dy), TPointD(dx, -dy));

  glDisable(GL_LINE_STIPPLE);

  // nome della camera

  if (!camera3d) {

    TPointD pos = rect.getP01() + TPointD(0, 4);

    std::string name;

    if (CleanupPreviewCheck::instance()->isEnabled())

      name = "Cleanup Camera";

    else

      name = xsh->getStageObject(cameraId)->getName();

    glPushMatrix();

    glTranslated(pos.x, pos.y, 0);

    glScaled(2, 2, 2);

    tglDrawText(TPointD(), name);

    glPopMatrix();

  }

  // draw preview sub-camera

  if (!CleanupPreviewCheck::instance()->isEnabled() && subcamera) {

    PreviewSubCameraManager *inst = PreviewSubCameraManager::instance();

    TRect previewSubRect(inst->getEditingCameraInterestRect());

    if (previewSubRect.getLx() > 0 && previewSubRect.getLy() > 0) {

      TRectD stagePreviewSubRect(inst->getEditingCameraInterestStageRect());

      glLineStipple(1, 0xCCCC);

      glEnable(GL_LINE_STIPPLE);

      glColor3d(1.0, 0.0, 1.0);

      glBegin(GL_LINE_STRIP);

      glVertex2d(stagePreviewSubRect.x0, stagePreviewSubRect.y0);

      glVertex2d(stagePreviewSubRect.x0, stagePreviewSubRect.y1 - pixelSize);

      glVertex2d(stagePreviewSubRect.x1 - pixelSize,

                 stagePreviewSubRect.y1 - pixelSize);

      glVertex2d(stagePreviewSubRect.x1 - pixelSize, stagePreviewSubRect.y0);

      glVertex2d(stagePreviewSubRect.x0, stagePreviewSubRect.y0);

      glEnd();

      glDisable(GL_LINE_STIPPLE);

    }

  }

}

//-----------------------------------------------------------------------------

void ViewerDraw::draw3DFrame(double minZ, double phi) {

  double a = Stage::bigBoxSize[0];

  double b = Stage::bigBoxSize[1];

  double c = Stage::bigBoxSize[2];

  double d = phi < 0 ? -a : a;

  double z0 = minZ;

  double z1 = 1000;

  glColor3d(0.9, 0.9, 0.86);

  glBegin(GL_LINES);

  glVertex3d(-a, -b, z0);

  glVertex3d(-a, -b, z1);

  glVertex3d(a, -b, z0);

  glVertex3d(a, -b, z1);

  glVertex3d(d, b, z0);

  glVertex3d(d, b, z1);

  glVertex3d(-a, -b, z0);

  glVertex3d(a, -b, z0);

  glVertex3d(d, -b, z0);

  glVertex3d(d, b, z0);

  glVertex3d(-a, -b, z1);

  glVertex3d(a, -b, z1);

  glVertex3d(d, -b, z1);

  glVertex3d(d, b, z1);

  glEnd();

  glColor3d(0.7, 0.7, 0.7);

  glBegin(GL_LINES);

  glVertex3d(0, -b, z0);

  glVertex3d(0, -b, z1);

  glVertex3d(d, 0, z0);

  glVertex3d(d, 0, z1);

  glEnd();

}

//-----------------------------------------------------------------------------

void ViewerDraw::drawFieldGuide() {

  double f = 1;  // controlla (indirettamente) la grandezza delle scritte

  TSceneProperties *sprop =

      TApp::instance()->getCurrentScene()->getScene()->getProperties();

  int n        = sprop->getFieldGuideSize();

  if (n < 4) n = 4;

  double ar    = sprop->getFieldGuideAspectRatio();

  double lx    = 0.5 * n / f * Stage::inch;  // 320;

  double ly    = lx / ar;

  glPushMatrix();

  glScaled(f, f, 1);

  double ux = lx / n;

  double uy = ly / n;

  glColor3d(.4, .4, .4);

  glBegin(GL_LINES);

  int i;

  for (i = -n; i <= n; i++) {

    glVertex2d(i * ux, -n * uy);

    glVertex2d(i * ux, n * uy);

    glVertex2d(-n * ux, i * uy);

    glVertex2d(n * ux, i * uy);

  }

  glVertex2d(-n * ux, -n * uy);

  glVertex2d(n * ux, n * uy);

  glVertex2d(-n * ux, n * uy);

  glVertex2d(n * ux, -n * uy);

  glEnd();

  for (i = 1; i <= n; i++) {

    TPointD delta = 0.03 * TPointD(ux, uy);

    std::string s = std::to_string(i);

    tglDrawText(TPointD(0, i * uy) + delta, s);

    tglDrawText(TPointD(0, -i * uy) + delta, s);

    tglDrawText(TPointD(-i * ux, 0) + delta, s);

    tglDrawText(TPointD(i * ux, 0) + delta, s);

  }

  glPopMatrix();

}

//-----------------------------------------------------------------------------

void ViewerDraw::drawDisk(int &tableDLId) {

  static TPixel32 currentBgColor;

  TPixel32 bgColor;

  if ((ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg))

    bgColor = TPixel::Black;

  else

    bgColor = Preferences::instance()->getViewerBgColor();

  if (tableDLId == -1 || currentBgColor != bgColor) {

    currentBgColor = bgColor;

    tableDLId      = createDiskDisplayList();

  }

  glCallList(tableDLId);

}

//-----------------------------------------------------------------------------

unsigned int ViewerDraw::createDiskDisplayList() {

  GLuint id = glGenLists(1);

  static std::vector<tpointd> sinCosTable;</tpointd>

  if (sinCosTable.empty()) {

    int n = 120;

    sinCosTable.resize(n);

    int i;

    for (i = 0; i < n; i++) {

      double ang       = 2 * 3.1415293 * i / n;

      sinCosTable[i].x = cos(ang);

      sinCosTable[i].y = sin(ang);

    }

  }

  double r = 10 * Stage::inch;

  glNewList(id, GL_COMPILE);

  glColor3d(.6, .65, .7);

  glBegin(GL_POLYGON);

  int i;

  int n = 120;

  for (i = 0; i < n; i++) tglVertex(r * sinCosTable[i]);

  glEnd();

  glColor3d(0, 0, 0);

  glBegin(GL_LINE_STRIP);

  for (i = 0; i < n; i++) tglVertex(r * sinCosTable[i]);

  tglVertex(r * sinCosTable[0]);

  glEnd();

  TPixel32 bgColor;

  if (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)

    bgColor = TPixel::Black;

  else

    bgColor = Preferences::instance()->getViewerBgColor();

  tglColor(bgColor);

  r *= 0.9;

  int m = 13;

  glBegin(GL_POLYGON);

  for (i = n - m; i < n; i++) tglVertex(r * sinCosTable[i]);

  for (i = 0; i <= m; i++) tglVertex(r * sinCosTable[i]);

  for (i = n / 2 - m; i <= n / 2 + m; i++) tglVertex(r * sinCosTable[i]);

  glEnd();

  // per non lasciare il colore corrente con il matte a zero

  glColor4d(0, 0, 0, 1);

  glEndList();

  return (id);

}