#include <cstring></cstring>

// TnzCore includes

#include "tsystem.h"

#include "tthread.h"

#include "tstopwatch.h"

#include "tvectorgl.h"

#include "tvectorrenderdata.h"

#include "tvectorimage.h"

#include "trasterimage.h"

#include "tlevel_io.h"

#include "tstrokeprop.h"

#include "ttessellator.h"

#include "tcolorfunctions.h"

#include "tofflinegl.h"

#include "drawutil.h"

#include "trop.h"

#include "tstencilcontrol.h"

#include "tpalette.h"

#include "tpixelutils.h"

#include "tregionprop.h"

#include "tcurves.h"

#include "tcurveutil.h"

#include "tstrokeoutline.h"

#include "tregion.h"

#include "tsimplecolorstyles.h"

#ifndef _WIN32

#define CALLBACK

#endif

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

TFilePath TRasterImagePatternStrokeStyle::m_rootDir = TFilePath();

TFilePath TVectorImagePatternStrokeStyle::m_rootDir = TFilePath();

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

#ifndef NDEBUG

static void checkGlError() {

  GLenum err = glGetError();

  assert(err != GL_INVALID_ENUM);

  assert(err != GL_INVALID_VALUE);

  assert(err != GL_INVALID_OPERATION);

  assert(err != GL_STACK_OVERFLOW);

  assert(err != GL_STACK_UNDERFLOW);

  assert(err != GL_OUT_OF_MEMORY);

  assert(err == GL_NO_ERROR);

}

#define CHECK_GL_ERROR checkGlError();

#else

#define CHECK_GL_ERROR

#endif

// Use GL_LINE_STRIP to debug the centerline-to-outline algorithm

#define QUAD_PRIMITIVE GL_QUAD_STRIP

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

//    Local namespace  stuff

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

namespace {

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

// se ras ha le dimensioni giuste (potenze di due) ritorna ras. Altrimenti

// crea il piu' piccolo raster con le dimensioni giuste che contenga ras e

// copia il contenuto (scalandolo)

// se il raster di partenza e' vuoto, non e' ras32 o e' piu' piccolo di 2x2

// ritorna un raster vuoto

TRaster32P makeTexture(const TRaster32P &ras) {

  if (!ras || ras->getLx() < 2 || ras->getLy() < 2) return TRaster32P();

  TRaster32P ras32 = ras;

  if (!ras32) return TRaster32P();

  TDimension d(2, 2);

  while (d.lx < 256 && d.lx * 2 <= ras32->getLx()) d.lx *= 2;

  while (d.ly < 256 && d.ly * 2 <= ras32->getLy()) d.ly *= 2;

  if (d == ras32->getSize())

    return ras32;

  else {

    TRaster32P texture(d);

    TScale sc((double)d.lx / ras32->getLx(), (double)d.ly / ras32->getLy());

    TRop::resample(texture, ras32, sc);

    return texture;

  }

}

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

class OutlineBuilder {

private:

  double width;

  int stage;

  double stages[3][3];

  double px, py, pz;

  double ax, ay;

  inline void next_stage(const double &x, const double &y, const double &z) {

    stages[stage][0] = x;

    stages[stage][1] = y;

    stages[stage][2] = z;

    ++stage;

  }

public:

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

  explicit OutlineBuilder(double width, int count = 0)

      : width(width), stage(0), px(), py(), pz(), ax(), ay() {

    memset(stages, 0, sizeof(stages));

    vertices.reserve(12 * (count + 2));

  }

  void add(double x, double y, double z = 0.0) {

    const double maxl = 4.0;

    if (stage == 0)

      next_stage(x, y, z);

    else {

      double bx = x - px;

      double by = y - py;

      double lb = sqrt(bx * bx + by * by);

      if (lb < 1e-9) return;

      bx = width * bx / lb;

      by = width * by / lb;

      if (stage == 1)

        next_stage(x, y, z);

      else {

        if (stage == 2) next_stage(x, y, z);

        double l = fabs(ax + bx) > 1e-9   ? -(ay - by) / (ax + bx)

                   : fabs(ay + by) > 1e-9 ? (ax - bx) / (ay + by)

                                          : 0.0;

        if (fabs(l) > maxl || fabs(l) < 1.0 || l > 0.0) {

          vertices.resize(vertices.size() + 12);

          double *p = &vertices.back() - 11;

          p[0]      = px;

          p[1]      = py;

          p[2]      = pz;

          p[3]      = px + ay;

          p[4]      = py - ax;

          p[5]      = pz;

          p[6]      = px;

          p[7]      = py;

          p[8]      = pz;

          p[9]      = px + by;

          p[10]     = py - bx;

          p[11]     = pz;

        } else {

          vertices.resize(vertices.size() + 6);

          double *p = &vertices.back() - 5;

          p[0]      = px;

          p[1]      = py;

          p[2]      = pz;

          p[3]      = px - l * bx + by;

          p[4]      = py - l * by - bx;

          p[5]      = pz;

        }

      }

      ax = bx;

      ay = by;

    }

    px = x;

    py = y;

    pz = z;

  }

  void finish() {

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

      add(stages[i][0], stages[i][1], stages[i][2]);

    stage = 0;

  }

  double get_width() const { return width; }

  void restart(double width) {

    this->width = width;

    stage       = 0;

    vertices.clear();

  }

  void invert() { restart(-width); }

};

void vector4_div(double *v) {

  double k = fabs(v[3]) > 1e-9 ? 1.0 / v[3] : 0.0;

  v[0] *= k, v[1] *= k, v[2] *= k;

  v[3] = 1.0;

}

void matrix4_x_vector4(double *dv, const double *m, const double *v) {

  dv[0] = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12] * v[3];

  dv[1] = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13] * v[3];

  dv[2] = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14] * v[3];

  dv[3] = m[3] * v[0] + m[7] * v[1] + m[11] * v[2] + m[15] * v[3];

}

void matrix4_x_matrix4(double *dm, const double *ma, const double *mb) {

  matrix4_x_vector4(dm + 0, ma, mb + 0);

  matrix4_x_vector4(dm + 4, ma, mb + 4);

  matrix4_x_vector4(dm + 8, ma, mb + 8);

  matrix4_x_vector4(dm + 12, ma, mb + 12);

}

class AntialiasingOutlinePainter : public OutlineBuilder {

private:

  double matrix[16];

  double projection_matrix[16];

  double modelview_matrix[16];

  double anti_viewport_matrix[16];

public:

  explicit AntialiasingOutlinePainter(int count = 0) : OutlineBuilder(1.0, 0) {

    memset(matrix, 0, sizeof(matrix));

    memset(projection_matrix, 0, sizeof(projection_matrix));

    memset(modelview_matrix, 0, sizeof(modelview_matrix));

    memset(anti_viewport_matrix, 0, sizeof(anti_viewport_matrix));

    // read transformations

    double viewport[4] = {};

    glGetDoublev(GL_VIEWPORT, viewport);

    glGetDoublev(GL_PROJECTION_MATRIX, projection_matrix);

    glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix);

    double viewport_matrix[16] = {};

    viewport_matrix[0]         = 0.5 * viewport[2];

    viewport_matrix[5]         = 0.5 * viewport[3];

    viewport_matrix[10]        = 1.0;

    viewport_matrix[12]        = 0.5 * viewport[2];

    viewport_matrix[13]        = 0.5 * viewport[3];

    viewport_matrix[15]        = 1.0;

    anti_viewport_matrix[0]  = 2.0 / viewport[2];

    anti_viewport_matrix[5]  = 2.0 / viewport[3];

    anti_viewport_matrix[10] = 1.0;

    anti_viewport_matrix[12] = -1.0;

    anti_viewport_matrix[13] = -1.0;

    anti_viewport_matrix[15] = 1.0;

    {

      double tmp[16] = {};

      matrix4_x_matrix4(tmp, projection_matrix, modelview_matrix);

      matrix4_x_matrix4(matrix, viewport_matrix, tmp);

    }

  }

  void add(double x, double y, double z = 0.0) {

    double dest[4], src[4] = {x, y, z, 1.0};

    matrix4_x_vector4(dest, matrix, src);

    vector4_div(dest);

    OutlineBuilder::add(dest[0], dest[1], dest[2]);

  }

  void finish() {

    OutlineBuilder::finish();

    if (vertices.empty()) return;

    int count = (int)vertices.size() / 6;

    // prepare colors

    float color[8] = {};

    glGetFloatv(GL_CURRENT_COLOR, color);

    memcpy(color + 4, color, 3 * sizeof(float));

    std::vector<float> colors(8 * count);</float>

    for (float *c = &colors[0], *ce = &colors.back(); c < ce; c += 8)

      memcpy(c, color, sizeof(color));

    // draw

    glMatrixMode(GL_MODELVIEW);

    glLoadMatrixd(anti_viewport_matrix);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glEnableClientState(GL_VERTEX_ARRAY);

    glEnableClientState(GL_COLOR_ARRAY);

    glVertexPointer(3, GL_DOUBLE, 0, &vertices.front());

    glColorPointer(4, GL_FLOAT, 0, &colors.front());

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 2 * count);

    glDisableClientState(GL_VERTEX_ARRAY);

    glDisableClientState(GL_COLOR_ARRAY);

    glLoadMatrixd(projection_matrix);

    glMatrixMode(GL_MODELVIEW);

    glLoadMatrixd(modelview_matrix);

    glColor4fv(color);

    restart(get_width());

  }

};

void drawAntialiasedOutline(const std::vector<toutlinepoint> &_v,</toutlinepoint>

                            const TStroke *stroke) {

  if (_v.empty()) return;

  const TOutlinePoint *begin = &_v.front(), *end = &_v.back();

  assert(_v.size() % 2 == 0);

  AntialiasingOutlinePainter outline(_v.size());

  for (const TOutlinePoint *i = begin; i < end; i += 2) outline.add(i->x, i->y);

  for (const TOutlinePoint *i = end; i > begin; i -= 2) outline.add(i->x, i->y);

  outline.finish();

  outline.invert();

  for (const TOutlinePoint *i = begin; i < end; i += 2) outline.add(i->x, i->y);

  for (const TOutlinePoint *i = end; i > begin; i -= 2) outline.add(i->x, i->y);

  outline.finish();

}

void drawAliasedOutline(const std::vector<toutlinepoint> &_v,</toutlinepoint>

                        const TStroke *stroke) {

  static const int stride = 2 * sizeof(TOutlinePoint);

  glEnableClientState(GL_VERTEX_ARRAY);

  glVertexPointer(2, GL_DOUBLE, stride, &_v[0]);

  glDrawArrays(GL_LINE_STRIP, 0, _v.size() / 2);

  glVertexPointer(2, GL_DOUBLE, stride, &_v[1]);

  glDrawArrays(GL_LINE_STRIP, 0, _v.size() / 2);

  glDisableClientState(GL_VERTEX_ARRAY);

}

}  // namespace

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

//    DisplayListManager  definition

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

#ifdef _WIN32

namespace {

class DisplayListManager  // singleton

{

public:

  TThread::Mutex m_mutex;

  typedef HGLRC T_hGlContext;

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

  struct Key {

    std::string m_name;

    TFrameId m_fid;

    T_hGlContext m_glContext;

    Key(std::string name, TFrameId fid, T_hGlContext glContext)

        : m_name(name), m_fid(fid), m_glContext(glContext) {}

  };

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

  struct Info {

    GLuint m_displayListId;

    TColorFunction::Parameters m_parameters;

    HDC m_hdc;

    Info()

        : m_displayListId(0)

        , m_hdc(0)

        , m_parameters(TColorFunction::Parameters()) {}

    Info(GLuint displayListId, HDC hdc, TColorFunction::Parameters parameters)

        : m_displayListId(displayListId)

        , m_hdc(hdc)

        , m_parameters(parameters) {}

    // se ad una stessa chiave corrispondono due displayInfo diversi (second

    // questo metodo),

    // si aggiorna la displayList secondo l'ultima chiamata.

    // Serve per non duplicare troppe liste, per parametri che non cambiano

    // spesso, come le cf.

    bool isDrawnAs(const Info &linfo) {

      return (this->m_parameters.m_mR == linfo.m_parameters.m_mR &&

              this->m_parameters.m_mG == linfo.m_parameters.m_mG &&

              this->m_parameters.m_mB == linfo.m_parameters.m_mB &&

              this->m_parameters.m_mM == linfo.m_parameters.m_mM &&

              this->m_parameters.m_cR == linfo.m_parameters.m_cR &&

              this->m_parameters.m_cG == linfo.m_parameters.m_cG &&

              this->m_parameters.m_cB == linfo.m_parameters.m_cB &&

              this->m_parameters.m_cM == linfo.m_parameters.m_cM);

    }

  };

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

  struct KeyLess final : public std::binary_function<key, bool="" key,=""> {</key,>

    bool operator()(const Key &d1, const Key &d2) const {

      return d1.m_glContext < d2.m_glContext ||

             (d1.m_glContext == d2.m_glContext &&

              (d1.m_fid < d2.m_fid ||

               d1.m_fid == d2.m_fid && d1.m_name < d2.m_name));

    }

  };

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

  typedef std::map<key, info,="" keyless=""> DisplayListMap;</key,>

private:

  DisplayListMap m_displayListMap;

  DisplayListManager() {}

  void recordList(GLuint listId, TVectorImage *image,

                  const TVectorRenderData &rd) {

    QMutexLocker sl(&m_mutex);

    TRectD bbox = image->getBBox();

    double ry   = bbox.getLy() * 0.5;

    if (ry < 1e-5) ry = 1e-5;

    TAffine identity;

    TRect rect;

    glPushMatrix();

    glLoadIdentity();

    // forzo pixelSize come se si disegnasse su una stroke con thickness=10

    // tglMultMatrix(TScale(10.0/ry));

    // forzo pixelSize a 20.

    // In questo modo, un'immagine piu' grande (nel pli

    // che definisce il custom style) viene piu' definita di una piu' piccola,

    // anche se appaiono della stessa dimensione (che dipende esclusivamente

    // dalla thickness)

    // tglMultMatrix(TScale(0.50));

    TPalette *vPalette = image->getPalette();

    assert(vPalette);

    TVectorRenderData rd2(identity, rect, vPalette, rd.m_cf, true, true);

    rd2.m_isOfflineRender = rd.m_isOfflineRender;

    rd2.m_isImagePattern  = true;

    CHECK_GL_ERROR

    glNewList(listId, GL_COMPILE);

    CHECK_GL_ERROR

    tglDraw(rd2, image);

    CHECK_GL_ERROR

    glEndList();

    CHECK_GL_ERROR

    glPopMatrix();

    CHECK_GL_ERROR

  }

public:

  static DisplayListManager *instance() {

    static DisplayListManager singleton;

    return &singleton;

  }

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

  GLuint getDisplayListId(TVectorImage *image, std::string name, TFrameId fid,

                          const TVectorRenderData &rd) {

    QMutexLocker sl(&m_mutex);

    TColorFunction::Parameters parameters;

    if (rd.m_cf) rd.m_cf->getParameters(parameters);

    CHECK_GL_ERROR

    HDC hDC               = wglGetCurrentDC();

    T_hGlContext hContext = wglGetCurrentContext();

    Info listInfo(0, hDC, parameters);

    Key key(name, fid, hContext);

    DisplayListMap::iterator it = m_displayListMap.find(key);

    if (it != m_displayListMap.end()) {

      if (listInfo.isDrawnAs(it->second)) {

        // lascia tutto com'e' ed utilizza la displaliList

        listInfo.m_displayListId = it->second.m_displayListId;

      } else {  // aggiorna la displayList con le nuove info (attualmente solo

                // la cf)

        listInfo.m_displayListId = it->second.m_displayListId;

        recordList(listInfo.m_displayListId, image, rd);

        m_displayListMap[key] = listInfo;

      }

    } else  // se non ho mai disegnato l'immagine creo la displayList

    {

      CHECK_GL_ERROR

      listInfo.m_displayListId = glGenLists(1);

      if (listInfo.m_displayListId != 0)

        recordList(listInfo.m_displayListId, image, rd);

      else

        std::cout << "list of " << name << fid << " is 0." << std::endl;

      CHECK_GL_ERROR

      m_displayListMap[key] = listInfo;

    }

    return listInfo.m_displayListId;

  }

  void clearLists() {

    // save current context and others

    HDC hCurrentDC               = wglGetCurrentDC();

    T_hGlContext hCurrentContext = wglGetCurrentContext();

    // free all display lists

    DisplayListMap::iterator it = m_displayListMap.begin();

    for (; it != m_displayListMap.end(); ++it) {

      wglMakeCurrent(it->second.m_hdc, it->first.m_glContext);

      glDeleteLists(it->second.m_displayListId, 1);

    }

    m_displayListMap.clear();

    // restore current context

    wglMakeCurrent(hCurrentDC, hCurrentContext);

  }

};

}  // namespace

#endif  // _WIN32

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

//    TSimpleStrokeStyle  implementation

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

TStrokeProp *TSimpleStrokeStyle::makeStrokeProp(const TStroke *stroke) {

  return new TSimpleStrokeProp(stroke, this);

}

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

//    TOutlineStyle  implementation

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

TOutlineStyle::TOutlineStyle() : m_regionOutlineModifier(0) {}

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

TOutlineStyle::TOutlineStyle(const TOutlineStyle &other)

    : TColorStyle(other)

    , m_regionOutlineModifier(other.m_regionOutlineModifier

                                  ? other.m_regionOutlineModifier->clone()

                                  : 0) {}

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

TOutlineStyle::~TOutlineStyle() { delete m_regionOutlineModifier; }

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

void TOutlineStyle::setRegionOutlineModifier(RegionOutlineModifier *modifier) {

  delete m_regionOutlineModifier;

  m_regionOutlineModifier = modifier;

}

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

TStrokeProp *TOutlineStyle::makeStrokeProp(const TStroke *stroke) {

  return new OutlineStrokeProp(stroke, this);

}

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

TRegionProp *TOutlineStyle::makeRegionProp(const TRegion *region) {

  return new OutlineRegionProp(region, this);

}

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

void TOutlineStyle::computeOutline(const TStroke *stroke,

                                   TStrokeOutline &outline,

                                   TOutlineUtil::OutlineParameter param) const {

  TOutlineUtil::makeOutline(*stroke, outline, param);

}

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

//    TSolidColorStyle  implementation

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

TSolidColorStyle::TSolidColorStyle(const TPixel32 &color)

    : m_color(color), m_tessellator(new TglTessellator) {}

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

TSolidColorStyle::TSolidColorStyle(const TSolidColorStyle &other)

    : TOutlineStyle(other)

    , m_color(other.m_color)

    , m_tessellator(new TglTessellator) {}

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

TSolidColorStyle::~TSolidColorStyle() { delete m_tessellator; }

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

TColorStyle *TSolidColorStyle::clone() const {

  return new TSolidColorStyle(*this);

}

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

void TSolidColorStyle::makeIcon(const TDimension &size) {

  /*-- TSolidColorStyle, TColorCleanupStyle, TBlackCleanupStyle --*/

  if (getTagId() != 3 && getTagId() != 2001 &&

      getTagId() !=

          2002)  // e' un'istanza di una classe derivata da TSolidColorStyle

  {

    TColorStyle::makeIcon(size);

  } else {

    if (!m_icon || m_icon->getSize() != size) {

      TRaster32P ras(size);

      m_icon = ras;

    }

    TPixel32 col = m_color;

    if (col.m == 255)

      m_icon->fill(col);

    else {

      TRaster32P fg(size);

      fg->fill(premultiply(col));

      TRop::checkBoard(m_icon, TPixel32::Black, TPixel32::White,

                       TDimensionD(6, 6), TPointD());

      TRop::over(m_icon, fg);

    }

  }

}

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

void TSolidColorStyle::drawRegion(const TColorFunction *cf,

                                  const bool antiAliasing,

                                  TRegionOutline &boundary) const {

  m_tessellator->tessellate(cf, antiAliasing, boundary, m_color);

}

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

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

void TSolidColorStyle::doDrawStroke(const TColorFunction *cf,

                                    TStrokeOutline *outline,

                                    const TStroke *stroke,

                                    bool antialias) const {

  struct locals {

    static inline void fillOutlinedStroke(const std::vector<toutlinepoint> &v) {</toutlinepoint>

      static const int stride = sizeof(TOutlinePoint);

      glEnableClientState(GL_VERTEX_ARRAY);

      glVertexPointer(2, GL_DOUBLE, stride, &v[0]);

      glDrawArrays(QUAD_PRIMITIVE, 0, v.size());

      glDisableClientState(GL_VERTEX_ARRAY);

    }

  };  // locals

  TPixel32 color = m_color;

  if (cf) color = (*cf)(color);

  if (color.m == 0) return;

  tglColor(color);

  const std::vector<toutlinepoint> &v = outline->getArray();</toutlinepoint>

  if (v.empty()) return;

  if (true)  // color.m != 254) // !dummyStyle)

  {

    if (color.m < 255) {

      TStencilControl *stencil = TStencilControl::instance();

      /*

// invertendo l'ordine tra disegno interno e contorno, l'antialiasing

// peggiora un po'. Piu che altro, il mangiucchiamento che faceva su alcune

macchine,

// ma solo in drawOnScreen, ora lo fa anche quando si renderizza offline

stencil->beginMask(TStencilControl::DRAW_ON_SCREEN_ONLY_ONCE);

// center line

fillOutlinedStroke(v);

// outline with antialiasing

drawAntialiasedOutline(v);

stencil->endMask();

*/

      stencil->beginMask(TStencilControl::DRAW_ON_SCREEN_ONLY_ONCE);

      locals::fillOutlinedStroke(v);

      stencil->endMask();

      stencil->enableMask(TStencilControl::SHOW_OUTSIDE);

      if (antialias)

        drawAntialiasedOutline(v, stroke);

      else

        drawAliasedOutline(v, stroke);

      stencil->disableMask();

    } else {

      // outline with antialiasing

      if (antialias)

        drawAntialiasedOutline(v, stroke);

      else

        drawAliasedOutline(v, stroke);

      // center line

      locals::fillOutlinedStroke(v);

    }

  } else {

    int i = 0;

    for (i = 0; i < stroke->getControlPointCount(); i++) {

      TThickPoint p = stroke->getControlPoint(i);

      if (i % 2) {

        tglColor(TPixel32(255, 0, 0));

        tglDrawCircle(p, p.thick);

      } else {

        tglColor(TPixel32(255, 200, 200));

        tglDrawDisk(p, p.thick);

        tglColor(TPixel32(0, 255, 0));

        tglDrawCircle(p, p.thick);

      }

      tglColor(TPixel32(127, 127, 127));

      tglDrawDisk(p, 0.3);

    }

    tglColor(TPixel32(127, 127, 127));

    glBegin(GL_LINE_STRIP);

    for (i = 0; i < stroke->getControlPointCount(); i++)

      tglVertex(stroke->getControlPoint(i));

    glEnd();

    tglColor(TPixel32(0, 0, 0));

    drawAntialiasedOutline(v, stroke);

  }

}

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

QString TSolidColorStyle::getDescription() const { return "SolidColorStyle"; }

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

std::string TSolidColorStyle::getBrushIdName() const {

  return "SolidColorStyle";

}

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

std::size_t TSolidColorStyle::staticBrushIdHash() {

  static std::size_t bidHash = TColorStyle::generateHash("SolidColorStyle");

  return bidHash;

}

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

int TSolidColorStyle::getTagId() const { return 3; }

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

void TSolidColorStyle::loadData(TInputStreamInterface &is) {

  TPixel32 color;

  is >> color;

  m_color = color;

}

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

void TSolidColorStyle::saveData(TOutputStreamInterface &os) const {

  os << m_color;

}

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

//    TCenterLineStrokeStyle  implementation

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

TCenterLineStrokeStyle::TCenterLineStrokeStyle(const TPixel32 &color,

                                               USHORT stipple, double width)

    : m_color(color), m_stipple(stipple), m_width(width) {}

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

TColorStyle *TCenterLineStrokeStyle::clone() const {

  return new TCenterLineStrokeStyle(*this);

}

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

void TCenterLineStrokeStyle::drawStroke(const TColorFunction *cf,

                                        const TStroke *stroke) const {

  if (!stroke) return;

  // center line

  int i, n = stroke->getChunkCount();

  if (n == 0) return;

  TPixel32 color = m_color;

  if (cf) color = (*cf)(m_color);

  if (color.m == 0) return;

  tglColor(color);

  double pixelSize = sqrt(tglGetPixelSize2());

  if (m_stipple != 0) {

    glEnable(GL_LINE_STIPPLE);

    glLineStipple(1, m_stipple);

  }

  const TThickQuadratic *q = 0;

  q                        = stroke->getChunk(0);

  GLfloat rangeValue[2];

  glGetFloatv(GL_LINE_WIDTH_RANGE, &rangeValue[0]);

  float width = float(m_width);

  if (width < rangeValue[0])

    width = rangeValue[0];

  else if (width > rangeValue[1])

    width = rangeValue[1];

  width = 2 * width;

  if (width <= 1.0) {

    if (m_width != 0.0) width /= pixelSize;

    if (width ==

        0.F)  // http://www.opengl.org/sdk/docs/man/xhtml/glLineWidth.xml

      width = 0.00001;

    glLineWidth(width);

    glBegin(GL_LINE_STRIP);

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

      q           = stroke->getChunk(i);

      double step = computeStep(*q, pixelSize);

      for (double t = 0; t < 1; t += step) tglVertex(q->getPoint(t));

    }

    assert(q);

    tglVertex(q->getP2());

    glEnd();

  } else {

    double s      = 0;

    double length = stroke->getLength();

    TPointD pos1, pos4;

    std::vector<tpointd> pv;</tpointd>

    width = width / 2.;

    while (s <= length) {

      double step = 1.0;

      double w    = stroke->getParameterAtLength(s);

      if (w <= 0) {

        s += 0.01;

        continue;

      }  // per tamponare il baco della getParameterAtLength()

      TPointD u = stroke->getSpeed(w);

      if (norm2(u) == 0) {

        s += 0.1;

        continue;

      }  // non dovrebbe succedere mai, ma per prudenza....

      TThickPoint pos = stroke->getThickPoint(w);

      u               = normalize(u);

      TPointD v       = rotate90(u) * (width);

      pos1            = pos + v;

      pos4            = pos - v;

      pv.push_back(pos1);

      pv.push_back(pos4);

      s += step;

    }

    double w = stroke->getParameterAtLength(length);

    if (w > 0) {