#include "regionstyles.h"

#include "tgl.h"

#include "tcolorfunctions.h"

#include "trandom.h"

#include "colorfxutils.h"

#include "tflash.h"

#include "tregion.h"

#include "tcurves.h"

#include "tmathutil.h"

#include "tstencilcontrol.h"

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

//    MovingModifier  implementation

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

TOutlineStyle::RegionOutlineModifier *MovingModifier::clone() const {

  return new MovingModifier(*this);

}

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

void MovingModifier::modify(TRegionOutline &outline) const {

  TRegionOutline::Boundary::iterator regIt    = outline.m_exterior.begin();

  TRegionOutline::Boundary::iterator regItEnd = outline.m_exterior.end();

  TRegionOutline::PointVector::iterator pIt;

  TRegionOutline::PointVector::iterator pItEnd;

  for (; regIt != regItEnd; ++regIt) {

    pIt    = regIt->begin();

    pItEnd = regIt->end();

    for (; pIt != pItEnd; ++pIt) {

      pIt->x += m_move.x;

      pIt->y += m_move.y;

    }

  }

  regIt    = outline.m_interior.begin();

  regItEnd = outline.m_interior.end();

  for (; regIt != regItEnd; ++regIt) {

    pIt    = regIt->begin();

    pItEnd = regIt->end();

    for (; pIt != pItEnd; ++pIt) {

      pIt->x += m_move.x;

      pIt->y += m_move.y;

    }

  }

}

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

//    MovingSolidColor  implementation

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

MovingSolidColor::MovingSolidColor(const TPixel32 &color, const TPointD &move)

    : TSolidColorStyle(color) {

  m_regionOutlineModifier = new MovingModifier(move);

}

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

TColorStyle *MovingSolidColor::clone() const {

  return new MovingSolidColor(*this);

}

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

void MovingSolidColor::loadData(TInputStreamInterface &is) {

  TSolidColorStyle::loadData(is);

  delete m_regionOutlineModifier;

  MovingModifier *mov = new MovingModifier(TPointD());

  mov->loadData(is);

  m_regionOutlineModifier = mov;

}

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

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

  TSolidColorStyle::saveData(os);

  assert(m_regionOutlineModifier);

  ((MovingModifier *)m_regionOutlineModifier)->saveData(os);

}

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

int MovingSolidColor::getParamCount() const { return 2; }

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

TColorStyle::ParamType MovingSolidColor::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString MovingSolidColor::getParamNames(int index) const {

  assert(0 <= index && index < 2);

  return index == 0

             ? QCoreApplication::translate("MovingSolidColor", "Horiz Offset")

             : QCoreApplication::translate("MovingSolidColor", "Vert Offset");

}

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

void MovingSolidColor::getParamRange(int index, double &min,

                                     double &max) const {

  assert(0 <= index && index < 2);

  min = -100.0;

  max = 100.0;

}

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

double MovingSolidColor::getParamValue(TColorStyle::double_tag,

                                       int index) const {

  assert(0 <= index && index < 2);

  if (index)

    return ((MovingModifier *)m_regionOutlineModifier)->getMovePoint().y;

  else

    return ((MovingModifier *)m_regionOutlineModifier)->getMovePoint().x;

}

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

void MovingSolidColor::setParamValue(int index, double value) {

  assert(0 <= index && index < 2);

  TPointD oldMove = ((MovingModifier *)m_regionOutlineModifier)->getMovePoint();

  if (!index) {

    if (oldMove.x != value) {

      delete m_regionOutlineModifier;

      oldMove.x               = value;

      m_regionOutlineModifier = new MovingModifier(oldMove);

      updateVersionNumber();

    }

  } else {

    if (oldMove.y != value) {

      delete m_regionOutlineModifier;

      oldMove.y               = value;

      m_regionOutlineModifier = new MovingModifier(oldMove);

      updateVersionNumber();

    }

  }

}

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

void MovingSolidColor::drawRegion(const TColorFunction *cf,

                                  const bool antiAliasing,

                                  TRegionOutline &boundary) const {

  TSolidColorStyle::drawRegion(cf, true, boundary);

}

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

void MovingSolidColor::drawRegion(TFlash &flash, const TRegion *r) const {

  SFlashUtils rdf(r);

  rdf.computeRegionOutline();

  m_regionOutlineModifier->modify(rdf.m_ro);

  flash.setFillColor(getMainColor());

  rdf.drawRegionOutline(flash, false);

}

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

//    ShadowStyle  implementation

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

ShadowStyle::ShadowStyle(const TPixel32 &bgColor, const TPixel32 &shadowColor,

                         const TPointD &shadowDirection, double len,

                         double density)

    : TSolidColorStyle(bgColor)

    , m_shadowColor(shadowColor)

    , m_shadowDirection(normalize(shadowDirection))

    , m_len(len)

    , m_density(density) {}

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

TColorStyle *ShadowStyle::clone() const { return new ShadowStyle(*this); }

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

void ShadowStyle::loadData(TInputStreamInterface &is) {

  TSolidColorStyle::loadData(is);

  is >> m_shadowDirection.x >> m_shadowDirection.y;

  is >> m_density;

  is >> m_shadowColor;

  is >> m_len;

}

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

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

  TSolidColorStyle::saveData(os);

  os << m_shadowDirection.x << m_shadowDirection.y;

  os << m_density;

  os << m_shadowColor;

  os << m_len;

}

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

int ShadowStyle::getParamCount() const { return 3; }

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

TColorStyle::ParamType ShadowStyle::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString ShadowStyle::getParamNames(int index) const {

  assert(0 <= index && index < 3);

  switch (index) {

  case 0:

    return QCoreApplication::translate("ShadowStyle", "Angle");

  case 1:

    return QCoreApplication::translate("ShadowStyle", "Density");

  case 2:

    return QCoreApplication::translate("ShadowStyle", "Length");

  default:

    return QString();

  }

  assert(0);

  return QString();

}

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

void ShadowStyle::getParamRange(int index, double &min, double &max) const {

  assert(0 <= index && index < 3);

  switch (index) {

  case 0:

    min = 0.0;

    max = 360.0;

    break;

  case 1:

    min = 0.0;

    max = 1.0;

    break;

  case 2:

    min = 0.0;

    max = 100.0;

    break;

  }

}

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

double ShadowStyle::getParamValue(TColorStyle::double_tag, int index) const {

  assert(0 <= index && index < 3);

  double degree;

  switch (index) {

  case 0:

    degree                              = asin(m_shadowDirection.y);

    if (m_shadowDirection.x < 0) degree = M_PI - degree;

    if (degree < 0) degree += M_2PI;

    return degree * M_180_PI;

  case 1:

    return m_density;

  case 2:

    return m_len;

  }

  assert(0);

  return 0.0;

}

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

void ShadowStyle::setParamValue(int index, double value) {

  assert(0 <= index && index < 3);

  double degree;

  switch (index) {

  case 0:

    degree              = value * M_PI_180;

    m_shadowDirection.x = cos(degree);

    m_shadowDirection.y = sin(degree);

    break;

  case 1:

    m_density = value;

    break;

  case 2:

    m_len = value;

    break;

  }

}

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

void ShadowStyle::drawPolyline(const TColorFunction *cf,

                               std::vector<t3dpointd> &polyline,</t3dpointd>

                               TPointD shadowDirection) const {

  int i;

  int stepNumber;

  double distance;

  TPointD v1, v2, diff, midPoint, ratio;

  double len;

  TPixel32 color;

  if (cf)

    color = (*(cf))(m_shadowColor);

  else

    color = m_shadowColor;

  tglColor(color);

  // glEnable(GL_BLEND);

  // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  //// <-- tglEnableBlending();

  TRegionOutline::PointVector::iterator it;

  TRegionOutline::PointVector::iterator it_b = polyline.begin();

  TRegionOutline::PointVector::iterator it_e = polyline.end();

  v1.x = polyline.back().x;

  v1.y = polyline.back().y;

  for (it = it_b; it != it_e; ++it) {

    v2.x = it->x;

    v2.y = it->y;

    if (v1 == v2) continue;

    diff = normalize(rotate90(v2 - v1));

    len  = diff * shadowDirection;

    if (len > 0) {

      distance = tdistance(v1, v2) * m_density;

      ratio      = (v2 - v1) * (1.0 / distance);

      midPoint   = v1;

      stepNumber = (int)distance;

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

        glBegin(GL_LINE_STRIP);

        tglColor(TPixel32(color.r, color.g, color.b, 0));

        tglVertex(midPoint);

        tglColor(color);

        tglVertex(midPoint + (shadowDirection * len * m_len * 0.5));

        tglColor(TPixel32(color.r, color.g, color.b, 0));

        tglVertex(midPoint + (shadowDirection * len * m_len));

        midPoint += ratio;

        glEnd();

      }

    }

    v1 = v2;

  }

  // tglColor(TPixel32::White);

}

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

void ShadowStyle::drawRegion(const TColorFunction *cf, const bool antiAliasing,

                             TRegionOutline ®ionOutline) const {

  TStencilControl *stenc = TStencilControl::instance();

  TPixel32 backgroundColor = TSolidColorStyle::getMainColor();

  if (cf) backgroundColor  = (*(cf))(backgroundColor);

  ////stenc->beginMask();

  /*

glBegin(GL_QUADS);

glVertex2d (regionOutline.m_bbox.getP00().x, regionOutline.m_bbox.getP00().y);

glVertex2d (regionOutline.m_bbox.getP01().x, regionOutline.m_bbox.getP01().y);

glVertex2d (regionOutline.m_bbox.getP11().x, regionOutline.m_bbox.getP11().y);

glVertex2d (regionOutline.m_bbox.getP10().x, regionOutline.m_bbox.getP10().y);

glEnd();

*/

  ////stenc->endMask();

  ////stenc->enableMask(TStencilControl::SHOW_INSIDE);

  if (backgroundColor.m == 0) {  // only to create stencil mask

    TSolidColorStyle appStyle(TPixel32::White);

    stenc->beginMask();

    appStyle.drawRegion(0, false, regionOutline);

  } else {

    stenc->beginMask(TStencilControl::DRAW_ALSO_ON_SCREEN);

    TSolidColorStyle::drawRegion(cf, antiAliasing, regionOutline);

  }

  stenc->endMask();

  stenc->enableMask(TStencilControl::SHOW_INSIDE);

  TRegionOutline::Boundary::iterator regions_it;

  TRegionOutline::Boundary::iterator regions_it_b =

      regionOutline.m_exterior.begin();

  TRegionOutline::Boundary::iterator regions_it_e =

      regionOutline.m_exterior.end();

  for (regions_it = regions_it_b; regions_it != regions_it_e; ++regions_it)

    drawPolyline(cf, *regions_it, m_shadowDirection);

  stenc->enableMask(TStencilControl::SHOW_OUTSIDE);

  regions_it_b = regionOutline.m_interior.begin();

  regions_it_e = regionOutline.m_interior.end();

  for (regions_it = regions_it_b; regions_it != regions_it_e; ++regions_it)

    drawPolyline(cf, *regions_it, -m_shadowDirection);

  // tglColor(TPixel32::White);

  stenc->disableMask();

}

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

/*

int ShadowStyle::drawPolyline(TFlash& flash, std::vector<t3dpointd> &polyline,</t3dpointd>

                                                           TPointD

shadowDirection, const bool isDraw) const

{

  int i;

  int stepNumber;

  double distance;

  TPointD v1,v2,diff,midPoint,ratio;

  double len;

  TRegionOutline::PointVector::iterator it;

  TRegionOutline::PointVector::iterator it_b = polyline.begin();

  TRegionOutline::PointVector::iterator it_e = polyline.end();

  std::vector<tsegment> segmentArray;</tsegment>

  v1.x = polyline.back().x;

  v1.y = polyline.back().y;

  for(it = it_b; it!= it_e; ++it)

  {

    v2.x = it->x;

    v2.y = it->y;

    if (v1==v2)

      continue;

    diff = normalize(rotate90(v2-v1));

    len=diff*shadowDirection;

    if(len>0)

    {

      distance = tdistance(v1,v2)*m_density;

      ratio= (v2-v1)*(1.0/distance);

      midPoint=v1;

      stepNumber= (int)distance;

      for(i=0; i

      {

                  std::vector<tsegment> sa;</tsegment>

                  TPointD p0=midPoint;

                  TPointD p1=midPoint+(shadowDirection*len*m_len*0.5);

                  TPointD p2=midPoint+(shadowDirection*len*m_len);

                  segmentArray.push_back(TSegment(p1,p0));

                  segmentArray.push_back(TSegment(p1,p2));

          midPoint += ratio;

      }

    }

    v1=v2;

  }

  if ( isDraw && segmentArray.size()>0 ) {

        flash.setLineColor(m_shadowColor);

        flash.drawSegments(segmentArray, true);

  }

  if ( segmentArray.size()>0 )

         return 1;

  return 0;

}

void ShadowStyle::drawRegion( TFlash& flash, const TRegion* r) const

{

  SFlashUtils rdf(r);

  rdf.computeRegionOutline();

  TRegionOutline::Boundary::iterator regions_it;

  TRegionOutline::Boundary::iterator regions_it_b =

rdf.m_ro.m_exterior->begin();

  TRegionOutline::Boundary::iterator regions_it_e = rdf.m_ro.m_exterior->end();

// In the GL version the shadow lines are not croped into the filled region.

// This is the reason why I don't calculate the number of shadow lines.

//  int nbDraw=0;

//  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

//	  nbDraw+=drawPolyline(flash,*regions_it, m_shadowDirection,false);

//  regions_it_b = rdf.m_ro.m_interior->begin();

//  regions_it_e = rdf.m_ro.m_interior->end();

//  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

//     nbDraw+=drawPolyline(flash,*regions_it,-m_shadowDirection,false);

// Only the bbox rectangle is croped.

  flash.drawRegion(*r,1);

  flash.setFillColor(getMainColor());

  flash.drawRectangle(rdf.m_ro.m_bbox);

  regions_it_b = rdf.m_ro.m_exterior->begin();

  regions_it_e = rdf.m_ro.m_exterior->end();

  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

          drawPolyline(flash,*regions_it, m_shadowDirection);

  regions_it_b = rdf.m_ro.m_interior->begin();

  regions_it_e = rdf.m_ro.m_interior->end();

  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

     drawPolyline(flash,*regions_it,-m_shadowDirection);

}

*/

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

TPixel32 ShadowStyle::getColorParamValue(int index) const {

  return index == 0 ? m_shadowColor : TSolidColorStyle::getMainColor();

}

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

void ShadowStyle::setColorParamValue(int index, const TPixel32 &color) {

  if (index == 0)

    m_shadowColor = color;

  else {

    TSolidColorStyle::setMainColor(color);

  }

}

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

void ShadowStyle::makeIcon(const TDimension &d) {

  double oldVal = getParamValue(TColorStyle::double_tag(), 1);

  setParamValue(1, oldVal * 0.25);

  TColorStyle::makeIcon(d);

  setParamValue(1, oldVal);

}

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

//    ShadowStyle2  implementation

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

ShadowStyle2::ShadowStyle2(const TPixel32 &bgColor, const TPixel32 &shadowColor,

                           const TPointD &shadowDirection, double shadowLength)

    : TSolidColorStyle(bgColor)

    , m_shadowColor(shadowColor)

    , m_shadowLength(shadowLength)

    , m_shadowDirection(normalize(shadowDirection)) {}

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

TColorStyle *ShadowStyle2::clone() const { return new ShadowStyle2(*this); }

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

void ShadowStyle2::loadData(TInputStreamInterface &is) {

  TSolidColorStyle::loadData(is);

  is >> m_shadowDirection.x >> m_shadowDirection.y;

  is >> m_shadowLength;

  is >> m_shadowColor;

}

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

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

  TSolidColorStyle::saveData(os);

  os << m_shadowDirection.x << m_shadowDirection.y;

  os << m_shadowLength;

  os << m_shadowColor;

}

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

int ShadowStyle2::getParamCount() const { return 2; }

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

TColorStyle::ParamType ShadowStyle2::getParamType(int index) const {

  assert(0 <= index && index < getParamCount());

  return TColorStyle::DOUBLE;

}

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

QString ShadowStyle2::getParamNames(int index) const {

  assert(0 <= index && index < 2);

  return index == 0 ? QCoreApplication::translate("ShadowStyle2", "Angle")

                    : QCoreApplication::translate("ShadowStyle2", "Size");

}

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

void ShadowStyle2::getParamRange(int index, double &min, double &max) const {

  assert(0 <= index && index < 2);

  if (index == 0) {

    min = 0.0;

    max = 360.0;

  } else {

    min = 0.0;

    max = 500.0;

  }

}

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

double ShadowStyle2::getParamValue(TColorStyle::double_tag, int index) const {

  assert(0 <= index && index < 2);

  if (index == 1) return m_shadowLength;

  double degree                       = asin(m_shadowDirection.y);

  if (m_shadowDirection.x < 0) degree = M_PI - degree;

  if (degree < 0) degree += M_2PI;

  return degree * M_180_PI;

}

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

static int nbDiffVerts(const std::vector<tpointd> &pv) {</tpointd>

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

  if (pv.size() == 0) return 0;

  lpv.push_back(pv[0]);

  for (int i = 1; i < (int)pv.size(); i++) {

    bool isDiff = true;

    for (int j = 0; j < (int)lpv.size() && isDiff; j++)

      isDiff = lpv[j] == pv[i] ? false : isDiff;

    if (isDiff) {

      lpv.push_back(pv[i]);

    }

  }

  return lpv.size();

}

void ShadowStyle2::setParamValue(int index, double value) {

  assert(0 <= index && index < 2);

  if (index == 1) {

    m_shadowLength = value;

  } else {

    double degree       = value * M_PI_180;

    m_shadowDirection.x = cos(degree);

    m_shadowDirection.y = sin(degree);

  }

}

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

namespace {

void drawShadowLine(TPixel32 shadowColor, TPixel32 color, TPointD v1,

                    TPointD v2, TPointD diff1, TPointD diff2) {

  v1    = v1 + diff1;

  v2    = v2 + diff2;

  diff1 = -diff1;

  diff2 = -diff2;

  double r1, r2;

  double t = 0.0;

  glBegin(GL_QUAD_STRIP);

  for (; t <= 1; t += 0.1) {

    r1 = t * t * t;

    r2 = 1 - r1;

    TPixel32 c((int)(color.r * r2 + shadowColor.r * r1),

               (int)(color.g * r2 + shadowColor.g * r1),

               (int)(color.b * r2 + shadowColor.b * r1),

               (int)(color.m * r2 + shadowColor.m * r1));

    tglColor(c);

    tglVertex(v1 + t * diff1);

    tglVertex(v2 + t * diff2);

  }

  glEnd();

}

int drawShadowLine(TFlash &flash, TPixel32 shadowColor, TPixel32 color,

                   TPointD v1, TPointD v2, TPointD diff1, TPointD diff2,

                   const bool isDraw = true) {

  int nbDraw = 0;

  v1    = v1 + diff1;

  v2    = v2 + diff2;

  diff1 = -diff1;

  diff2 = -diff2;

  TPointD vv1, vv2, ovv1, ovv2;

  TPixel32 oc;

  double r1, r2;

  double t     = 0.0;

  bool isFirst = true;

  flash.setThickness(0.0);

  SFlashUtils sfu;

  for (; t <= 1; t += 0.1) {

    if (isFirst) {

      r1 = t * t * t;

      r2 = 1 - r1;

      oc = TPixel32((int)(color.r * r2 + shadowColor.r * r1),

                    (int)(color.g * r2 + shadowColor.g * r1),

                    (int)(color.b * r2 + shadowColor.b * r1),

                    (int)(color.m * r2 + shadowColor.m * r1));

      ovv1    = v1 + t * diff1;

      ovv2    = v2 + t * diff2;

      isFirst = false;

    } else {

      r1 = t * t * t;

      r2 = 1 - r1;

      TPixel32 c((int)(color.r * r2 + shadowColor.r * r1),

                 (int)(color.g * r2 + shadowColor.g * r1),

                 (int)(color.b * r2 + shadowColor.b * r1),

                 (int)(color.m * r2 + shadowColor.m * r1));

      vv1 = (v1 + t * diff1);

      vv2 = (v2 + t * diff2);

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

      pv.push_back(ovv1);

      pv.push_back(ovv2);

      pv.push_back(vv2);

      pv.push_back(vv1);

      int nbDV = nbDiffVerts(pv);

      if (nbDV >= 3 && nbDV <= 4) nbDraw++;

      if (isDraw) sfu.drawGradedPolyline(flash, pv, oc, c);

      oc   = c;

      ovv1 = vv1;

      ovv2 = vv2;

    }

  }

  return nbDraw;

}

}

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

void ShadowStyle2::drawPolyline(const TColorFunction *cf,

                                const std::vector<t3dpointd> &polyline,</t3dpointd>

                                TPointD shadowDirection) const {

  if (polyline.empty()) return;

  TPointD v0, v1, diff;

  double len1, len2;

  TPixel32 color, shadowColor;

  if (cf)

    color = (*(cf))(TSolidColorStyle::getMainColor());

  else

    color = TSolidColorStyle::getMainColor();

  if (cf)

    shadowColor = (*(cf))(m_shadowColor);

  else

    shadowColor = m_shadowColor;

  tglColor(shadowColor);

  // glEnable(GL_BLEND);

  // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  //// <-- tglEnableBlending();

  TRegionOutline::PointVector::const_iterator it;

  TRegionOutline::PointVector::const_iterator it_b = polyline.begin();

  TRegionOutline::PointVector::const_iterator it_e = polyline.end();

  int size = polyline.size();

  std::vector<double> lens(size);</double>

  v0.x      = polyline.back().x;

  v0.y      = polyline.back().y;

  int count = 0;

  for (it = it_b; it != it_e; ++it) {

    v1.x = it->x;

    v1.y = it->y;

    if (v1 != v0) {

      diff               = normalize(rotate90(v1 - v0));

      len1               = diff * shadowDirection;

      if (len1 < 0) len1 = 0;

      lens[count++]      = len1;

    } else

      lens[count++] = 0;

    v0 = v1;

  }

  double firstVal = lens.front();

  for (count = 0; count != size - 1; count++) {

    lens[count] = (lens[count] + lens[count + 1]) * 0.5;

  }

  lens[size - 1] = (lens[size - 1] + firstVal) * 0.5;

  for (count = 0; count != size - 1; count++) {

    v0.x = polyline[count].x;

    v0.y = polyline[count].y;

    v1.x = polyline[count + 1].x;

    v1.y = polyline[count + 1].y;

    len1 = lens[count];

    len2 = lens[count + 1];

    if (v0 != v1 && len1 >= 0 && len2 >= 0 && (len1 + len2) > 0)

      drawShadowLine(shadowColor, color, v0, v1,

                     shadowDirection * len1 * m_shadowLength,

                     shadowDirection * len2 * m_shadowLength);

  }

  v0.x = polyline[count].x;

  v0.y = polyline[count].y;

  v1.x = polyline.front().x;

  v1.y = polyline.front().y;

  len1 = lens[count];

  len2 = lens[0];

  if (v0 != v1 && len1 >= 0 && len2 >= 0 && (len1 + len2) > 0)

    drawShadowLine(shadowColor, color, v0, v1,

                   shadowDirection * len1 * m_shadowLength,

                   shadowDirection * len2 * m_shadowLength);

  // tglColor(TPixel32::White);

}

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

TPixel32 ShadowStyle2::getColorParamValue(int index) const {

  return index == 0 ? m_shadowColor : TSolidColorStyle::getMainColor();

}

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

void ShadowStyle2::setColorParamValue(int index, const TPixel32 &color) {

  if (index == 0)

    m_shadowColor = color;

  else {

    TSolidColorStyle::setMainColor(color);

  }

}

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

void ShadowStyle2::drawRegion(const TColorFunction *cf, const bool antiAliasing,

                              TRegionOutline &boundary) const {

  TStencilControl *stenc   = TStencilControl::instance();

  TPixel32 backgroundColor = TSolidColorStyle::getMainColor();

  if (cf) backgroundColor  = (*(cf))(backgroundColor);