#include <CLGradientStops.h>

Collaboration diagram for CLGradientStops:

Public Member Functions
	CLGradientStops (const CLGradientBase *pGradient, const std::map< std::string, CLRGBAColor > &colormap)

const CLRGBAColor &	color () const

void	update_color (double val)

	~CLGradientStops ()

Protected Member Functions
void	adjust_value (double &value) const

Protected Attributes
std::list< std::pair< double, unsigned int > >::const_iterator	mBegin

CLRGBAColor	mColor

unsigned char *	mColorData

std::list< std::pair< double, unsigned int > >::const_iterator	mCurrentPosition

std::list< std::pair< double, unsigned int > >::const_iterator	mEnd

double	mHelp

unsigned int	mIndex

CLGradientBase::SPREADMETHOD	mSpreadMethod

std::list< std::pair< double, unsigned int > >	mStops

std::list< std::pair< double, unsigned int > >::const_iterator	mTmp

Detailed Description

Definition at line 25 of file CLGradientStops.h.

Constructor & Destructor Documentation

CLGradientStops::CLGradientStops	(	const CLGradientBase *	pGradient,
		const std::map< std::string, CLRGBAColor > &	colormap
	)

Definition at line 14 of file CLGradientStops.cpp.

References CLGradientBase::getGradientStop(), CLGradientBase::getNumGradientStops(), CLGradientStop::getOffset(), CLRelAbsVector::getRelativeValue(), CLGradientStop::getStopColor(), mBegin, mColorData, mCurrentPosition, mEnd, mIndex, and mStops.

   : mSpreadMethod(pGradient->getSpreadMethod()), mColorData(NULL), mIndex(0), mHelp(0.0)
 {
   size_t i, iMax = pGradient->getNumGradientStops();
 
   if (iMax > 0)
     {
       this->mColorData = new unsigned char[4 * iMax];
       this->mIndex = 0;
       const CLGradientStop* pStop = NULL;
       std::string stopColor;
       std::map<std::string, CLRGBAColor>::const_iterator pos;
       double v = 0.0;
       std::list<std::pair<double, unsigned int> >::reverse_iterator last;
 
       for (i = 0; i < iMax; ++i)
         {
           pStop = pGradient->getGradientStop(i);
           assert(pStop != NULL);
           stopColor = pStop->getStopColor();
           assert(stopColor.find_first_not_of(" \t\n\r") != std::string::npos && stopColor != "none");
           pos = colormap.find(stopColor);
           assert(pos != colormap.end());
           // offsets can only be relative values, so we ignore the absolute part
           v = pStop->getOffset().getRelativeValue() / 100.0;
 
           // we cap at 0.0 and 1.0
           if (v < 0.0)
             {
               v = 0.0;
             }
 
           if (v > 1.0)
             {
               v = 1.0;
             }
 
           // make sure each stop has an offset
           // greater or equal to the preceeding
           // offset
           if (i != 0)
             {
               if (v < last->first)
                 {
                   v = last->first;
                 }
             }
 
           //std::cout << "adding stop: (" << v << "," << this->mIndex << ")" << std::endl;
           mStops.push_back(std::pair<double, unsigned int>(v, this->mIndex));
           last = this->mStops.rbegin();
           this->mColorData[this->mIndex] = pos->second.mR;
           this->mColorData[++this->mIndex] = pos->second.mG;
           this->mColorData[++this->mIndex] = pos->second.mB;
           this->mColorData[++this->mIndex] = pos->second.mA;
           ++this->mIndex;
           //std::cout << "stop color: (" << (unsigned int)pos->second.r << "," << (unsigned int)pos->second.g << "," << (unsigned int)pos->second.b << "," << (unsigned int)pos->second.a << ")" << std::endl;
         }
     }
   else
     {
       // we add one color which is completly transparent black
       this->mColorData = new unsigned char[4];
       this->mColorData[0] = 0;
       this->mColorData[1] = 0;
       this->mColorData[2] = 0;
       this->mColorData[3] = 0;
       this->mStops.push_back(std::pair<double, unsigned int>(0.0, 0));
     }
 
   this->mBegin = this->mStops.begin();
   this->mEnd = this->mStops.end();
   this->mCurrentPosition = this->mBegin;
 }

CLGradientStops::~CLGradientStops ( )

Definition at line 89 of file CLGradientStops.cpp.

References mColorData.

 {
   if (this->mColorData != NULL)
     {
       delete[] this->mColorData;
     }
 }

Member Function Documentation

void CLGradientStops::adjust_value ( double & value ) const

protected

This method takes the given offset value and adjust it if it is outside the rangr from 0.0 to 1.0 depending on the spread method that has been set from the gradient.

Definition at line 179 of file CLGradientStops.cpp.

References mSpreadMethod, CLGradientBase::PAD, CLGradientBase::REFLECT, and CLGradientBase::REPEAT.

Referenced by update_color().

 {
   if (value < 0.0)
     {
       switch (this->mSpreadMethod)
         {
           case CLGradientBase::PAD:
             value = 0.0;
             break;
 
           case CLGradientBase::REFLECT:
             // if the part of the distance before the decimal point
             // is devisible by 2, we just remove it
             // otherwise, we remove it and subtract the result from
             // 1.0
             value = fabs(value);
 
             if (((unsigned int)floor(value)) % 2 != 0)
               {
                 value = 1.0 - (value - floor(value));
               }
             else
               {
                 value = value - floor(value);
               }
 
             break;
 
           case CLGradientBase::REPEAT:
             // we only need everything after the decimal point
             // and we need to subtract from 1.0
             value = value - floor(value);
             break;
         }
     }
   else if (value > 1.0)
     {
       switch (this->mSpreadMethod)
         {
           case CLGradientBase::PAD:
             value = 1.0;
             break;
 
           case CLGradientBase::REFLECT:
 
             // if the part of the distance before the decimal point
             // is devisible by 2, we just remove it
             // otherwise, we remove it and subtract the result from
             // 1.0
             if (((unsigned int)floor(value)) % 2 != 0)
               {
                 value = 1.0 - (value - floor(value));
               }
             else
               {
                 value = value - floor(value);
               }
 
             break;
 
           case CLGradientBase::REPEAT:
             // we only need everything after the decimal point
             value = value - floor(value);
             break;
         }
     }
 }

const CLRGBAColor & CLGradientStops::color ( ) const

Definition at line 174 of file CLGradientStops.cpp.

References mColor.

Referenced by CLLayoutRenderer::create_linear_gradient_texture(), and CLLayoutRenderer::create_radial_gradient_texture().

 {
   return this->mColor;
 }

void CLGradientStops::update_color ( double val )

Given a relative value, this routine returns a const pointer to an rgba value that is 4 unsigned char long. If the gradient that was used to create the CLGradientStops object didn't have any gradient stops, the color that is returned is completly transparent black.

Definition at line 104 of file CLGradientStops.cpp.

References adjust_value(), CLRGBAColor::mA, CLRGBAColor::mB, mBegin, mColor, mColorData, mCurrentPosition, mEnd, CLRGBAColor::mG, mHelp, mIndex, CLRGBAColor::mR, and mTmp.

Referenced by CLLayoutRenderer::create_linear_gradient_texture(), and CLLayoutRenderer::create_radial_gradient_texture().

 {
   this->adjust_value(val);
   this->mTmp = this->mCurrentPosition;
 
   //double v=this->mCurrentPosition->first;
   if (val >= this->mCurrentPosition->first)
     {
       while (mTmp != mEnd && this->mTmp->first <= val)
         {
           ++this->mTmp;
           //v=this->mTmp->first;
         }
 
       this->mCurrentPosition = this->mTmp;
 
       if (this->mCurrentPosition == this->mEnd || this->mCurrentPosition->first > val)
         {
           --this->mCurrentPosition;
         }
 
       //v=this->mCurrentPosition->first;
       this->mIndex = this->mCurrentPosition->second;
       this->mColor.mR = this->mColorData[this->mIndex];
       this->mColor.mG = this->mColorData[++this->mIndex];
       this->mColor.mB = this->mColorData[++this->mIndex];
       this->mColor.mA = this->mColorData[++this->mIndex];
 
       if (this->mCurrentPosition->first < val && this->mTmp != this->mEnd)
         {
           // we need to calculate the exact color value from mTmp and mCurrentPosition
           //v=this->mTmp->first;
           mHelp = (val - this->mCurrentPosition->first) / (this->mTmp->first - this->mCurrentPosition->first);
           this->mColor.mR += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mR));
           this->mColor.mG += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mG));
           this->mColor.mB += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mB));
           this->mColor.mA += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mA));
         }
     }
   else
     {
       // the value must be smaller than the value at the current position
       while (this->mTmp != this->mBegin && val < this->mTmp->first)
         {
           //v=this->mTmp->first;
           --this->mTmp;
         }
 
       this->mCurrentPosition = this->mTmp;
       //v=this->mCurrentPosition->first;
       this->mIndex = this->mCurrentPosition->second;
       this->mColor.mR = this->mColorData[this->mIndex];
       this->mColor.mG = this->mColorData[++this->mIndex];
       this->mColor.mB = this->mColorData[++this->mIndex];
       this->mColor.mA = this->mColorData[++this->mIndex];
 
       if (val > this->mTmp->first)
         {
           // we need to calculate the correct value
           ++this->mTmp;
           //v=this->mTmp->first;
           mHelp = (val - this->mCurrentPosition->first) / (this->mTmp->first - this->mCurrentPosition->first);
           this->mColor.mR += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mR));
           this->mColor.mG += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mG));
           this->mColor.mB += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mB));
           this->mColor.mA += (unsigned char)(mHelp * (double)(this->mColorData[++this->mIndex] - this->mColor.mA));
         }
     }
 }