//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------

#include "gfx/gfxInit.h"
#include "gfx/primBuilder.h"
#include "gfx/gfxDrawUtil.h"
#include "console/console.h"
#include "console/consoleTypes.h"
#include "console/engineAPI.h"
#include "gui/core/guiCanvas.h"

#include "gui/editor/guiParticleGraphCtrl.h"

IMPLEMENT_CONOBJECT(GuiParticleGraphCtrl);

ConsoleDocClass( GuiParticleGraphCtrl,
   "@brief Legacy remnant from old Torque particle editor\n\n"
   "Editor use only.\n\n"
   "@internal"
);

GuiParticleGraphCtrl::GuiParticleGraphCtrl()
{

   for(S32 i = 0; i < MaxPlots; i++)
   {
      mPlots[i].mGraphColor = LinearColorF(1.0, 1.0, 1.0);
      VECTOR_SET_ASSOCIATION(mPlots[i].mGraphData);
      mPlots[i].mGraphMax.x = 1;
      mPlots[i].mGraphMax.y = 50;
      mPlots[i].mGraphMin.x = 0;
      mPlots[i].mGraphMin.y = 0;
      mPlots[i].mGraphType = Polyline;
      mPlots[i].mGraphName = StringTable->EmptyString();
      mPlots[i].mHidden = false;
      mPlots[i].mGraphScale = 0.05f;
   }

   mPlots[0].mGraphColor = LinearColorF(1.0f, 0.2f, 0.2f);
   mPlots[1].mGraphColor = LinearColorF(1.0f, 0.5f, 0.5f);
   mPlots[2].mGraphColor = LinearColorF(0.0f, 1.0f, 0.0f);
   mPlots[3].mGraphColor = LinearColorF(0.0f, 0.0f, 1.0f);
   mPlots[4].mGraphColor = LinearColorF(0.0f, 1.0f, 1.0f);
   mPlots[5].mGraphColor = LinearColorF(0.0f, 0.0f, 0.0f);
   mPlots[6].mGraphColor = LinearColorF(0.5f, 0.5f, 0.5f);
   mPlots[7].mGraphColor = LinearColorF(0.5f, 0.0f, 0.0f);
   mPlots[8].mGraphColor = LinearColorF(0.0f, 0.5f, 0.0f);
   mPlots[9].mGraphColor = LinearColorF(0.0f, 0.0f, 0.5f);
   mPlots[10].mGraphColor = LinearColorF(0.0f, 0.5f, 0.5f);
   mPlots[11].mGraphColor = LinearColorF(0.25f, 0.25f, 0.25f);
   mPlots[12].mGraphColor = LinearColorF(0.5f, 0.5f, 0.5f);
   mPlots[13].mGraphColor = LinearColorF(0.5f, 0.0f, 0.0f);
   mPlots[14].mGraphColor = LinearColorF(0.0f, 0.5f, 0.0f);
   mPlots[15].mGraphColor = LinearColorF(0.0f, 0.0f, 0.5f);
   mPlots[16].mGraphColor = LinearColorF(0.0f, 0.5f, 0.5f);
   mPlots[17].mGraphColor = LinearColorF(0.25f, 0.25f, 0.25f);
   mPlots[18].mGraphColor = LinearColorF(1.0f, 0.2f, 0.2f);
   mPlots[19].mGraphColor = LinearColorF(1.0f, 0.5f, 0.5f);
   mPlots[20].mGraphColor = LinearColorF(0.0f, 1.0f, 0.0f);
   mPlots[21].mGraphColor = LinearColorF(0.0f, 0.0f, 1.0f);
   mPlots[22].mGraphColor = LinearColorF(0.0f, 1.0f, 1.0f);
   mPlots[23].mGraphColor = LinearColorF(0.0f, 0.0f, 0.0f);
   mPlots[24].mGraphColor = LinearColorF(0.5f, 0.5f, 0.5f);
   mPlots[25].mGraphColor = LinearColorF(0.5f, 0.0f, 0.0f);
   mPlots[26].mGraphColor = LinearColorF(0.0f, 0.5f, 0.0f);
   mPlots[27].mGraphColor = LinearColorF(0.0f, 0.0f, 0.5f);
   mPlots[28].mGraphColor = LinearColorF(1.0f, 0.0f, 0.0f);
   mPlots[29].mGraphColor = LinearColorF(0.0f, 1.0f, 0.0f);
   mPlots[30].mGraphColor = LinearColorF(0.0f, 0.0f, 1.0f);
   mPlots[31].mGraphColor = LinearColorF(0.5f, 0.0f, 0.0f);

   mVertexClickSize = 6;
   mSelectedPlot = 0;
   mSelectedPoint = -1;
   mOriginalSelectedPoint = -1;
   mLastSelectedPoint = -1;
   mAddedPointIndex = -1;
   mAutoMax = false;
   mAutoRemove = false;
   mRenderAllPoints = false;
   mRenderGraphTooltip = true;
   mPointWasAdded = false;
   mPointXMovementClamped = false;
   mOutlineColor = ColorI(1, 1, 1);
   mCursorPos = Point2I(0, 0);
   mTooltipSelectedPlot = 0;
   mRenderNextGraphTooltip = false;
}

ImplementEnumType( GuiParticleGraphType,
   "\n\n"
   "@ingroup GuiCore" 
   "@internal")
   { GuiParticleGraphCtrl::Bar,        "bar"      },
   { GuiParticleGraphCtrl::Filled,     "filled"   },
   { GuiParticleGraphCtrl::Point,      "point"    },
   { GuiParticleGraphCtrl::Polyline ,  "polyline" },
EndImplementEnumType;

bool GuiParticleGraphCtrl::onWake()
{
   if (! Parent::onWake())
      return false;
   setActive(true);
   return true;
}

void GuiParticleGraphCtrl::onRender(Point2I offset, const RectI &updateRect)
{
   // Fetch Draw Utility.
   GFXDrawUtil* pDrawUtil = GFX->getDrawUtil();

   if (mProfile->mBorder)
   {
      const RectI bounds = getBounds();
      RectI rect(offset.x, offset.y, bounds.extent.x, bounds.extent.y);    
      pDrawUtil->drawRect(rect, mProfile->mBorderColor);
   }

   GuiControlProfile* profile = dynamic_cast<GuiControlProfile*>(Sim::findObject("GuiDefaultProfile"));
   Resource<GFont> font = profile->mFont;
   GFXVideoMode videoMode = GFXInit::getDesktopResolution();

   ColorI color(255, 255, 255, 128);
   pDrawUtil->drawRectFill(updateRect, color);

   for (S32 k = 0; k < MaxPlots; k++)
   {
      // Nothing to graph
      if ((mPlots[k].mGraphData.size() == 0) || (mPlots[k].mHidden == true))
         continue;
   
        Point2F graphExtent = getGraphExtent(k);

      // Adjust scale to max value + 5% so we can see high value
      F32 ScaleX = (F32(getExtent().x) / (graphExtent.x*(1.00 + (mPlots[k].mGraphScale))));
      F32 ScaleY = (F32(getExtent().y) / (graphExtent.y*(1.00 + (mPlots[k].mGraphScale))));

      if((mPlots[k].mGraphType == Point) || (mPlots[k].mGraphType == Polyline))
      {
         S32 posX;
         S32 posY;
         S32 lastPosX = 0;
         S32 lastPosY = 0;
         Point2F plotPoint;

         S32 size = 32;

         for (S32 sample = 0; sample < mPlots[k].mGraphData.size(); sample++)
         {
            S32 temp;

            temp = (S32)(((F32)getExtent().x / (F32)mPlots[k].mGraphData.size()) * (F32)sample);

            // calculate the point positions
            plotPoint = getPlotPoint(k, sample);

            posX = (S32)((plotPoint.x - mPlots[k].mGraphMin.x) * (ScaleX /(1.00 + mPlots[k].mGraphScale)));
            posY = (getExtent().y) - (S32)((plotPoint.y  - mPlots[k].mGraphMin.y) * ScaleY);

            posX += getExtent().x * (mPlots[k].mGraphScale);
            posY /= (1.00 + (mPlots[k].mGraphScale));

            posX = localToGlobalCoord(Point2I(posX, posY)).x;
            posY = localToGlobalCoord(Point2I(posX, posY)).y;

            // check if this isn't our first loop through, if it is we won't have starting points
            if(sample > 0)
            {
               pDrawUtil->drawLine( lastPosX, lastPosY , posX, posY , mPlots[k].mGraphColor.toColorI() );
            } else
            {
               mPlots[k].mNutList.clear();
            }

            mPlots[k].mNutList.push_back( Point2F(posX, posY) );

            // store the last positions to be the starting points drawn into a line next loop
            lastPosX = posX;
            lastPosY = posY;

            //Con::printf("red %f green %f blue %f", mPlots[k].mGraphColor.red, mPlots[k].mGraphColor.green, mPlots[k].mGraphColor.blue);



            if(mSelectedPoint != -1)
            {
               mLastSelectedPoint = mSelectedPoint;
            }

            ColorI nutColor (mPlots[k].mGraphColor.toColorI());

            if(k == mSelectedPlot && sample == mLastSelectedPoint)
            {
               // grab the colors for the nut
               F32 red = mPlots[k].mGraphColor.red;
               F32 green = mPlots[k].mGraphColor.green;
               F32 blue = mPlots[k].mGraphColor.blue;

               // invert the colors for the nut since this is a selected nut
               red = 1.0 - red; 
               green = 1.0 - green;
               blue = 1.0 - blue;
               // nut color

               nutColor = LinearColorF(red, green, blue).toColorI();
            } 

            // draw the seleciton nut
            drawNut( Point2I(posX, posY), 3, mOutlineColor, nutColor );

            if((mLastSelectedPoint != -1) || (mRenderAllPoints == true))
            {
               if((k == mSelectedPlot && sample == mLastSelectedPoint) || (mRenderAllPoints == true))
               {
                  char number[32];

                  Point2I comparePos = localToGlobalCoord(Point2I(getPosition().x, getPosition().y));

                  dSprintf(number, 32, "%4.3f %4.3f", plotPoint.x, plotPoint.y);

                  S32 textWidth = (S32)font->getStrWidth((const UTF8*)number);;
                  textWidth /= 2;

                  if((((S32)posX - (textWidth/2)) < comparePos.x) || (((S32)posX - textWidth) <= 0))
                  {
                      posX += (textWidth/1.5);
                 } else if((posX + (textWidth * 1.8)) > (comparePos.x + getExtent().x) || ((posX + textWidth) >= videoMode.resolution.x))
                  {
                      posX -= (textWidth * 1.5);
                  }

                  if((((S32)posY) < comparePos.y) || (((S32)posY - textWidth) <= 0))
                  {
                      posY += 40;
                  } 
            
                 pDrawUtil->setBitmapModulation( profile->mFontColor );
                 pDrawUtil->drawText( font, Point2I(posX, posY + 5) - Point2I(size >> 1, size), number );
                 pDrawUtil->clearBitmapModulation();
               }
            }
         }
      }
   }

   if(mRenderNextGraphTooltip == true && mRenderGraphTooltip == true)
   {
       char argBuffer[1][32];
   
       dSprintf(argBuffer[0], 32, "%s", getGraphName(mTooltipSelectedPlot));

      renderGraphTooltip(mCursorPos, argBuffer[0]);
   }
}

S32 GuiParticleGraphCtrl::addPlotPoint(S32 plotID, Point2F v, bool setAdded)
{
   S32 mPlotIndex = 0;
   bool plotChanged = false;
   bool plotAdded = false;

   if(mAutoMax == false)
   {
      if(v.x < mPlots[plotID].mGraphMin.x)
      {
         v.x = mPlots[plotID].mGraphMin.x;
      } 

      if(v.x > mPlots[plotID].mGraphMax.x)
      {
         v.x = mPlots[plotID].mGraphMax.x;
      }

      if(v.y < mPlots[plotID].mGraphMin.y)
      {
         v.y = mPlots[plotID].mGraphMin.y;
      } 

      if(v.y > mPlots[plotID].mGraphMax.y)
      {
         v.y = mPlots[plotID].mGraphMax.y;
      }
   }

   for(S32 i = 0; i < mPlots[plotID].mGraphData.size(); i++)
   {         
      if(mFabs(v.x - mPlots[plotID].mGraphData[i].x) < 0.001)
      {
         if(mAutoRemove == true)
         {
            changePlotPoint(plotID, i, v);
            plotChanged = true;
            mPlotIndex = i;
         } else
         {
            mPlotIndex = -1;
         }
         
         plotAdded = true;
        
         break;
      } else if(v.x < mPlots[plotID].mGraphData[i].x)
      {
          insertPlotPoint(plotID, i, v); 
        plotAdded = true;
        mPlotIndex = i;
        break;
      }
   }

   if(plotAdded == false)
   {
      mPlots[plotID].mGraphData.push_back( v );
      mPlotIndex = mPlots[plotID].mGraphData.size() - 1;
   }

   if(mAutoMax == true)
   {
      // Keep record of maximum data value for scaling purposes.
      if(v.y > mPlots[plotID].mGraphMax.y)
        mPlots[plotID].mGraphMax.y = v.y;

      if(v.x > mPlots[plotID].mGraphMax.x)
        mPlots[plotID].mGraphMax.x = v.x;
   }

   if(plotChanged == true)
   {
      mPointWasAdded = false;  
   } else if(mPlotIndex != -1 && setAdded)
   {
      mPointWasAdded = true;
      mAddedPoint = v;
      mAddedPointIndex = mPlotIndex;
   }

   return mPlotIndex;
}

void GuiParticleGraphCtrl::insertPlotPoint(S32 plotID, S32 i, Point2F v)
{
   //AssertFatal(plotID > -1 && plotID < MaxPlots, "Invalid plot specified!");

   // Add the data and trim the vector...
   mPlots[plotID].mGraphData.insert( i );
   mPlots[plotID].mGraphData[ i ] = v;

   if(mAutoMax == true)
   {
      // Keep record of maximum data value for scaling purposes.
      if(v.y > mPlots[plotID].mGraphMax.y)
        mPlots[plotID].mGraphMax.y = v.y;

      if(v.x > mPlots[plotID].mGraphMax.x)
        mPlots[plotID].mGraphMax.x = v.x;
   }

   // Argument Buffer.
   char argBuffer[2][32];
   
   dSprintf(argBuffer[0], 32, "%d", plotID);
   dSprintf(argBuffer[1], 32, "%f %f", v.x, v.y);

   // Call Scripts.
   Con::executef(this, "onPlotPointInserted", argBuffer[0], argBuffer[1]);
}

S32 GuiParticleGraphCtrl::changePlotPoint(S32 plotID, S32 i, Point2F v)
{
   //AssertFatal(plotID > -1 && plotID < MaxPlots, "Invalid plot specified!");

   // Add the data and trim the vector...
   S32 point = removePlotPoint(plotID, i);

   // Argument Buffer.
   char argBuffer[3][32];
   
   dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
   dSprintf(argBuffer[1], 32, "%d", point);
   dSprintf(argBuffer[2], 32, "%f %f", v.x, v.y);

   // Call Scripts.
   Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
   
   // call the insert function
   S32 index = addPlotPoint(plotID, v);

   return index;
}

S32 GuiParticleGraphCtrl::removePlotPoint(S32 plotID, S32 i)
{
   if((plotID < MaxPlots && plotID >= 0) && (i < mPlots[plotID].mGraphData.size()))
   {
      Point2F v = mPlots[plotID].mGraphData[i];

      mPlots[plotID].mGraphData.erase(i);

      if(i == mPlots[plotID].mGraphData.size() && mSelectedPlot == plotID && mLastSelectedPoint == i)
      {
         setSelectedPoint(i-1);
      } else if(i < mLastSelectedPoint)
      {
         setSelectedPoint(mLastSelectedPoint-1);
      }
   }

   return i;
}

S32 GuiParticleGraphCtrl::getSelectedPlot()
{
   return mSelectedPlot;
}

S32 GuiParticleGraphCtrl::getSelectedPoint()
{
   return mLastSelectedPoint;
}

bool GuiParticleGraphCtrl::isExistingPoint(S32 plotID, S32 sample)
{
   if (((plotID < 0) || (plotID >= MaxPlots)) || ((sample < 0) || (sample > MaxDataPoints)) || (sample >= mPlots[plotID].mGraphData.size()))
   {
      return false;
   } else
   {
      return true;
   }
}

Point2F GuiParticleGraphCtrl::getPlotPoint(S32 plotID, S32 sample)
{
   Point2F val;
   val.x = -1;
   val.y = -1;

   if (((plotID < 0) || (plotID >= MaxPlots)) || ((sample < 0) || (sample > MaxDataPoints)))
   {
      return val;
   }

   return mPlots[plotID].mGraphData[sample];
}

S32 GuiParticleGraphCtrl::getPlotIndex(S32 plotID, F32 x, F32 y)
{
   if ((plotID < 0) || (plotID >= MaxPlots))
   {
      return -1;
   } 

   F32 compareX = 0.0;
   F32 compareY = 0.0;

   for(S32 i = 0; i < mPlots[plotID].mGraphData.size(); i++)
   {
      compareX = mPlots[plotID].mGraphData[i].x;
      compareY = mPlots[plotID].mGraphData[i].y;

      //
      //if((x == compareX) && (y == compareY))
      if((mFabs(x - compareX) < 0.001) && (mFabs(y - compareY) < 0.001))
         return i;
   }

   return -1;
}

void GuiParticleGraphCtrl::setGraphType(S32 plotID, const char *graphType)
{
   AssertFatal(plotID > -1 && plotID < MaxPlots, "Invalid plot specified!");
   if(!dStricmp(graphType,"Bar"))
      mPlots[plotID].mGraphType = Bar;
   else if(!dStricmp(graphType,"Filled"))
      mPlots[plotID].mGraphType = Filled;
   else if(!dStricmp(graphType,"Point"))
      mPlots[plotID].mGraphType = Point;
   else if(!dStricmp(graphType,"Polyline"))
      mPlots[plotID].mGraphType = Polyline;
   else AssertWarn(true, "Invalid graph type!");
}

void GuiParticleGraphCtrl::setSelectedPlot(S32 plotID)
{
   mSelectedPlot = plotID;

   // Argument Buffer.
   char argBuffer[32];
   
   dSprintf(argBuffer, 32, "%d", plotID);

   // Call Scripts.
   Con::executef(this, "onSetSelected", argBuffer);
}

void GuiParticleGraphCtrl::setSelectedPoint(S32 point)
{
   if(point != mSelectedPoint && point < mPlots[mSelectedPlot].mGraphData.size() && point >= 0)
   {
      mSelectedPoint = point;
      mLastSelectedPoint = point;
      char argBuffer[32];

      dSprintf(argBuffer, 32, "%d", point);

      // Call Scripts.
      Con::executef(this, "onPlotPointSelected", argBuffer);
   }
}

void GuiParticleGraphCtrl::resetSelectedPoint()
{
   mSelectedPoint = -1;
}

void GuiParticleGraphCtrl::setAutoGraphMax(bool autoMax)
{
   mAutoMax = autoMax;
}

void GuiParticleGraphCtrl::setAutoRemove(bool autoRemove)
{
   mAutoRemove = autoRemove;
}

void GuiParticleGraphCtrl::setGraphHidden(S32 plotID, bool isHidden)
{
   mPlots[plotID].mHidden = isHidden;
}

void GuiParticleGraphCtrl::setRenderAll(bool renderAll)
{
   mRenderAllPoints = renderAll;
}

void GuiParticleGraphCtrl::setPointXMovementClamped(bool clamped)
{
   mPointXMovementClamped = clamped;
}

void GuiParticleGraphCtrl::setRenderGraphTooltip(bool renderGraphTooltip)
{
   mRenderGraphTooltip = renderGraphTooltip;
}


void GuiParticleGraphCtrl::drawNut(const Point2I &nut, S32 size, ColorI &outlineColor, ColorI &nutColor)
{
   // Fetch Draw Utility.
   GFXDrawUtil* pDrawUtil = GFX->getDrawUtil();

   //Con::printf("r %d g %d b %d", nutColor.red, nutColor.green, nutColor.blue);
   S32 NUT_SIZE = size;
   RectI r(nut.x - NUT_SIZE, nut.y - NUT_SIZE, 2 * NUT_SIZE + 1, 2 * NUT_SIZE + 1);
   r.inset(1, 1);
   pDrawUtil->drawRectFill(r, nutColor);
   r.inset(-1, -1);
   pDrawUtil->drawRect(r, outlineColor);
}

bool GuiParticleGraphCtrl::inNut(const Point2I &pt, S32 x, S32 y)
{
   S32 dx = pt.x - x;
   S32 dy = pt.y - y;
   return dx <= mVertexClickSize && dx >= -mVertexClickSize && dy <= mVertexClickSize && dy >= -mVertexClickSize;
}

Point2I GuiParticleGraphCtrl::findHitNut( Point2I hitPoint )
{
   for(S32 i = 0; i < MaxPlots; i++)
   {
     if ( (mPlots[i].mGraphData.size() == 0) || (mPlots[i].mHidden == true))
         continue;

      for (S32 j = 0 ; j < mPlots[i].mNutList.size(); j++ )
      {
        if( inNut (Point2I( mPlots[i].mNutList[j].x, mPlots[i].mNutList[j].y), hitPoint.x, hitPoint.y) )
       {
            mTooltipSelectedPlot = i; 
         return Point2I(i,j);
       }
     }
   }

   return Point2I(-1,-1);
}

Point2F GuiParticleGraphCtrl::convertToGraphCoord(S32 plotID, Point2I v)
{
   Point2F resultV;

   v = globalToLocalCoord( v );
   v.y = getExtent().y - v.y;
   resultV = Point2F(v.x, v.y);
   resultV.x /= getExtent().x; 
   resultV.y /= getExtent().y;
   resultV.x *= getGraphExtent(plotID).x;
   resultV.y *= getGraphExtent(plotID).y;
   resultV.x *= 1.00 + (mPlots[plotID].mGraphScale*2);
   resultV.y *= 1.00 + (mPlots[plotID].mGraphScale*2);
   resultV.x -= getGraphExtent(plotID).x * ((mPlots[plotID].mGraphScale));
   resultV.y -= getGraphExtent(plotID).y * ((mPlots[plotID].mGraphScale));
   resultV.x += mPlots[plotID].mGraphMin.x;
   resultV.y += mPlots[plotID].mGraphMin.y;

   if(mAutoMax == false)
   {
      if(resultV.x < mPlots[plotID].mGraphMin.x)
      {
         resultV.x = mPlots[plotID].mGraphMin.x;
      } 

      if(resultV.x > mPlots[plotID].mGraphMax.x)
      {
         resultV.x = mPlots[plotID].mGraphMax.x;
      }

      if(resultV.y < mPlots[plotID].mGraphMin.y)
      {
         resultV.y = mPlots[plotID].mGraphMin.y;
      } 

      if(resultV.y > mPlots[plotID].mGraphMax.y)
      {
         resultV.y = mPlots[plotID].mGraphMax.y;
      }
   }



   return resultV;
}

Point2F GuiParticleGraphCtrl::getGraphExtent(S32 plotID)
{
   Point2F resultV;

   resultV.x = mPlots[plotID].mGraphMax.x - mPlots[plotID].mGraphMin.x;
   resultV.y = mPlots[plotID].mGraphMax.y - mPlots[plotID].mGraphMin.y;

   return resultV;
}

LinearColorF GuiParticleGraphCtrl::getGraphColor(S32 plotID)
{
   return mPlots[plotID].mGraphColor;
}

Point2F GuiParticleGraphCtrl::getGraphMax(S32 plotID)
{
   return mPlots[plotID].mGraphMax;
}

Point2F GuiParticleGraphCtrl::getGraphMin(S32 plotID)
{
   return mPlots[plotID].mGraphMin;
}

void GuiParticleGraphCtrl::setGraphMin(S32 plotID, Point2F graphMin)
{
   mPlots[plotID].mGraphMin = graphMin;
}

void GuiParticleGraphCtrl::setGraphMax(S32 plotID, Point2F graphMax)
{
   mPlots[plotID].mGraphMax = graphMax;
}

void GuiParticleGraphCtrl::setGraphMinX(S32 plotID, F32 graphMinX)
{
   mPlots[plotID].mGraphMin.x = graphMinX;
}

void GuiParticleGraphCtrl::setGraphMinY(S32 plotID, F32 graphMinY)
{
   mPlots[plotID].mGraphMin.y = graphMinY;
}

void GuiParticleGraphCtrl::setGraphMaxX(S32 plotID, F32 graphMaxX)
{
   mPlots[plotID].mGraphMax.x = graphMaxX;
}

void GuiParticleGraphCtrl::setGraphMaxY(S32 plotID, F32 graphMaxY)
{
   mPlots[plotID].mGraphMax.y = graphMaxY;
}

void GuiParticleGraphCtrl::setGraphName(S32 plotID, StringTableEntry graphName)
{
   mPlots[plotID].mGraphName = StringTable->insert(graphName);
}

StringTableEntry GuiParticleGraphCtrl::getGraphName(S32 plotID)
{
   return mPlots[plotID].mGraphName;
}

void GuiParticleGraphCtrl::onMouseMove(const GuiEvent &event)
{
   mCursorPos = event.mousePoint;
   
   Point2I hitNut = findHitNut(event.mousePoint);

   if( hitNut != Point2I(-1,-1) )
   {
      mRenderNextGraphTooltip = true;
   } else
   {
      mRenderNextGraphTooltip = false;
   }

   // Argument Buffer.
   char argBuffer[32];
   
   dSprintf(argBuffer, 32, "%f %f", convertToGraphCoord(mSelectedPlot, event.mousePoint).x, convertToGraphCoord(mSelectedPlot, event.mousePoint).y);


   // Call Scripts.
   Con::executef(this, "onMouseMove", argBuffer);
}

void GuiParticleGraphCtrl::onMouseDown(const GuiEvent &event)
{
   Point2I hitNut = findHitNut(event.mousePoint);

   if( hitNut != Point2I(-1,-1) )
   {
     if(event.mouseClickCount == 2)
     {
        Point2F plotPoint = getPlotPoint(hitNut.x, hitNut.y);
        S32 point = removePlotPoint(hitNut.x, hitNut.y);

        // Argument Buffer.
        char argBuffer[3][32];
   
        dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
        dSprintf(argBuffer[1], 32, "%d", point);
        dSprintf(argBuffer[2], 32, "%f %f", plotPoint.x, plotPoint.y);

       

         // Call Scripts.
         Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
     } else
     {
        setSelectedPlot(hitNut.x);
        setSelectedPoint(hitNut.y);
        mOriginalSelectedPoint = hitNut.y;

        char argBuffer[32];

        dSprintf(argBuffer, 32, "%d", hitNut.y);

        // Call Scripts.
        Con::executef(this, "onPlotPointSelectedMouseDown", argBuffer);
     }
   } else if( mSelectedPlot != -1 ) 
   {  
      Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);
      mLastSelectedPoint = addPlotPoint(mSelectedPlot, mousePos);

      // Argument Buffer.
      char argBuffer[32];
   
      dSprintf(argBuffer, 32, "%f %f", convertToGraphCoord(mSelectedPlot, event.mousePoint).x, convertToGraphCoord(mSelectedPlot, event.mousePoint).y);

      // Call Scripts.
      Con::executef(this, "onMouseDragged", argBuffer);

      return;
   }
}

void GuiParticleGraphCtrl::onMouseUp(const GuiEvent &event)
{
   if(mSelectedPoint != -1)
     mLastSelectedPoint = mSelectedPoint;

   if(mPointWasAdded == true)
   {
      if(mSelectedPoint == -1)
      {
        // Argument Buffer.
         char argBuffer[3][32];
   
         dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
         dSprintf(argBuffer[1], 32, "%f %f", mAddedPoint.x, mAddedPoint.y);
         dSprintf(argBuffer[2], 32, "%d", mAddedPointIndex);
         
         // Call Scripts.
         Con::executef(this, "onPlotPointAdded", argBuffer[0], argBuffer[1], argBuffer[2]);
      } else
      {
         // Argument Buffer.
         char argBuffer[4][32];
   
         dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
         dSprintf(argBuffer[1], 32, "%f %f", mAddedPoint.x, mAddedPoint.y);
         dSprintf(argBuffer[2], 32, "%d", mOriginalSelectedPoint);
         dSprintf(argBuffer[3], 32, "%d", mAddedPointIndex);

         // Call Scripts.
         Con::executef(this, "onPlotPointChangedUp", argBuffer[0], argBuffer[1], argBuffer[2], argBuffer[3]);
     }
   }

   mPointWasAdded = false;

   mSelectedPoint = -1;
}

void GuiParticleGraphCtrl::onMouseDragged(const GuiEvent &event)
{
   mRenderNextGraphTooltip = false;

   if(mSelectedPoint != -1)
   {
      Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);

      if(mPointXMovementClamped == true)
      {
         F32 prevXPos = getPlotPoint(mSelectedPlot, mSelectedPoint).x;
         if(mousePos.x != prevXPos)
         {
            mousePos.x = prevXPos;
         }
      }

      removePlotPoint(mSelectedPlot, mSelectedPoint);
      S32 point = addPlotPoint(mSelectedPlot, mousePos);
      if(point != -1)
      {
         setSelectedPoint(point);
         mLastMousePos = mousePos;

         // Argument Buffer.
         char argBuffer[3][32];
   
         dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
         dSprintf(argBuffer[1], 32, "%f %f", mAddedPoint.x, mAddedPoint.y);
         dSprintf(argBuffer[2], 32, "%d", point);

         // Call Scripts.
         Con::executef(this, "onPlotPointChangedMove", argBuffer[0], argBuffer[1], argBuffer[2]);
      } else
      {
         point = addPlotPoint(mSelectedPlot, mLastMousePos);
      }
   }

   // Argument Buffer.
   char argBuffer[32];
   
   dSprintf(argBuffer, 32, "%f %f", convertToGraphCoord(mSelectedPlot, event.mousePoint).x, convertToGraphCoord(mSelectedPlot, event.mousePoint).y);

   // Call Scripts.
   Con::executef(this, "onMouseDragged", argBuffer);
}

void GuiParticleGraphCtrl::onRightMouseDown(const GuiEvent &event)
{
   Point2I hitNut = findHitNut(event.mousePoint);

   if( hitNut != Point2I(-1,-1) )
   {
      Point2F plotPoint = getPlotPoint(hitNut.x, hitNut.y);
      S32 point = removePlotPoint(hitNut.x, hitNut.y);

      // Argument Buffer.
      char argBuffer[3][32];
   
      dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
      dSprintf(argBuffer[1], 32, "%d", point);
      dSprintf(argBuffer[2], 32, "%f %f", plotPoint.x, plotPoint.y);

      // Call Scripts.
      Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
   } 
}

void GuiParticleGraphCtrl::onRightMouseUp(const GuiEvent &event)
{

}

void GuiParticleGraphCtrl::onRightMouseDragged(const GuiEvent &event)
{
   Point2I hitNut = findHitNut(event.mousePoint);

   if( hitNut != Point2I(-1,-1) )
   {
      Point2F plotPoint = getPlotPoint(hitNut.x, hitNut.y);
      S32 point = removePlotPoint(hitNut.x, hitNut.y);

      // Argument Buffer.
      char argBuffer[3][32];
   
      dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
      dSprintf(argBuffer[1], 32, "%d", point);
      dSprintf(argBuffer[2], 32, "%f %f", plotPoint.x, plotPoint.y);

      // Call Scripts.
      Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
   } 
}

void GuiParticleGraphCtrl::clearAllGraphs()
{
   for(S32 i = 0;i < MaxPlots;i++)
   {
      clearGraph(i);
   }
}

void GuiParticleGraphCtrl::clearGraph(S32 plotID)
{
   mPlots[plotID].mGraphData.clear();
   mPlots[plotID].mNutList.clear();
}

bool GuiParticleGraphCtrl::renderGraphTooltip(Point2I cursorPos, StringTableEntry tooltip)
{
   // Short Circuit.
   if (!mAwake) 
      return false;
   if ( dStrlen( tooltip ) == 0 )
      return false;

   // Need to have root.
   GuiCanvas *root = getRoot();
   if ( !root )
      return false;

   if (!mTooltipProfile)
      setTooltipProfile( mProfile );

   GFont *font = mTooltipProfile->mFont;

   // Fetch Canvas.
   GuiCanvas *pCanvas = getRoot();

   //Vars used:
   //Screensize (for position check)
   //Offset to get position of cursor
   //textBounds for text extent.
   Point2I screensize = pCanvas->getWindowSize();
   Point2I offset = cursorPos; 
   Point2I textBounds;
   S32 textWidth = font->getStrWidth(tooltip);

   //Offset below cursor image
   offset.y -= root->getCursorExtent().y;
   //Create text bounds.
   textBounds.x = textWidth+8;
   textBounds.y = font->getHeight() + 4;

   // Check position/width to make sure all of the tooltip will be rendered
   // 5 is given as a buffer against the edge
   if (screensize.x < offset.x + textBounds.x + 5)
      offset.x = screensize.x - textBounds.x - 5;

   // And ditto for the height
   if(screensize.y < offset.y + textBounds.y + 5)
      offset.y = cursorPos.y - textBounds.y - 5;

   // Set rectangle for the box, and set the clip rectangle.
   RectI rect(offset, textBounds);
   GFX->setClipRect(rect);

   // Fetch Draw Utility.
   GFXDrawUtil* pDrawUtil = GFX->getDrawUtil();

   // Draw Filler bit, then border on top of that
   pDrawUtil->drawRectFill(rect, ColorI(mTooltipProfile->mFillColor.red, mTooltipProfile->mFillColor.green, mTooltipProfile->mFillColor.blue, 200) );
   pDrawUtil->drawRect( rect, mTooltipProfile->mBorderColor );

   // Draw the text centered in the tool tip box
   pDrawUtil->setBitmapModulation( mTooltipProfile->mFontColor );
   Point2I start;
   start.set( ( textBounds.x - textWidth) / 2, ( textBounds.y - font->getHeight() ) / 2 );
   pDrawUtil->drawText( font, start + offset, tooltip, mProfile->mFontColors );
   pDrawUtil->clearBitmapModulation();

   return true;
}

DefineEngineMethod(GuiParticleGraphCtrl, setSelectedPoint, void, (S32 point), , "(int point)"
              "Set the selected point on the graph.\n"
           "@return No return value")
{
   if(point >= object->mPlots[object->mSelectedPlot].mGraphData.size() || point < 0)
   {
      Con::errorf("Invalid point to select.");
      return;
   }
   object->setSelectedPoint( point );
}

DefineEngineMethod(GuiParticleGraphCtrl, setSelectedPlot, void, (S32 plotID), , "(int plotID)"
              "Set the selected plot (a.k.a. graph)."
           "@return No return value" )
{
   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }
   object->setSelectedPlot( plotID );
}

DefineEngineMethod(GuiParticleGraphCtrl, clearGraph, void, (S32 plotID), , "(int plotID)"
              "Clear the graph of the given plot."
           "@return No return value")
{
   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }
   object->clearGraph( plotID );
}

DefineEngineMethod(GuiParticleGraphCtrl, clearAllGraphs, void, (), , "()"
              "Clear all of the graphs."
           "@return No return value")
{
   object->clearAllGraphs();
}

DefineEngineMethod(GuiParticleGraphCtrl, addPlotPoint, S32, (S32 plotID, F32 x, F32 y, bool setAdded), (true), "(int plotID, float x, float y, bool setAdded = true;)"
              "Add a data point to the given plot."
           "@return")
{
  
   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return -2;
   }
   return object->addPlotPoint( plotID, Point2F(x, y), setAdded);
}

DefineEngineMethod(GuiParticleGraphCtrl, insertPlotPoint, void, (S32 plotID, S32 i, F32 x, F32 y), , "(int plotID, int i, float x, float y)\n"
              "Insert a data point to the given plot and plot position.\n"
           "@param plotID The plot you want to access\n"
           "@param i The data point.\n"
           "@param x,y The plot position.\n"
           "@return No return value.")
{
   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }
   object->insertPlotPoint( plotID, i, Point2F(x, y));
}

DefineEngineMethod(GuiParticleGraphCtrl, changePlotPoint, S32, (S32 plotID, S32 i, F32 x, F32 y), , "(int plotID, int i, float x, float y)"
              "Change a data point to the given plot and plot position.\n"
           "@param plotID The plot you want to access\n"
           "@param i The data point.\n"
           "@param x,y The plot position.\n"
           "@return No return value.")
{
   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return -1;
   }
   return object->changePlotPoint( plotID, i, Point2F(x, y));
}

DefineEngineMethod(GuiParticleGraphCtrl, getSelectedPlot, S32, (), , "() "
              "Gets the selected Plot (a.k.a. graph).\n"
           "@return The plot's ID.")
{
  return object->getSelectedPlot();
}

DefineEngineMethod(GuiParticleGraphCtrl, getSelectedPoint, S32, (), , "()"
              "Gets the selected Point on the Plot (a.k.a. graph)."
           "@return The last selected point ID")
{
   return object->getSelectedPoint();
}

DefineEngineMethod(GuiParticleGraphCtrl, isExistingPoint, bool, (S32 plotID, S32 samples), , "(int plotID, int samples)"
              "@return Returns true or false whether or not the point in the plot passed is an existing point.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }
   if(samples > object->MaxDataPoints)
   {
      Con::errorf("Invalid sample.");
   }
   return object->isExistingPoint(plotID, samples);
}

DefineEngineMethod(GuiParticleGraphCtrl, getPlotPoint, Point2F, (S32 plotID, S32 samples), , "(int plotID, int samples)"
              "Get a data point from the plot specified, samples from the start of the graph."
           "@return The data point ID")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }
   if(samples > object->MaxDataPoints)
   {
      Con::errorf("Invalid sample.");
   }

   
   return object->getPlotPoint(plotID, samples);
}

DefineEngineMethod(GuiParticleGraphCtrl, getPlotIndex, S32, (S32 plotID, F32 x, F32 y), , "(int plotID, float x, float y)\n"
              "Gets the index of the point passed on the plotID passed (graph ID).\n"
           "@param plotID The plot you wish to check.\n"
           "@param x,y The coordinates of the point to get.\n"
           "@return Returns the index of the point.\n")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }
   return object->getPlotIndex(plotID, x, y);
}

DefineEngineMethod(GuiParticleGraphCtrl, getGraphColor, LinearColorF, (S32 plotID), , "(int plotID)"
              "Get the color of the graph passed."
           "@return Returns the color of the graph as a string of RGB values formatted as \"R G B\"")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }
  
   return object->getGraphColor(plotID);
   
}

DefineEngineMethod(GuiParticleGraphCtrl, getGraphMin, Point2F, (S32 plotID), , "(int plotID) "
              "Get the minimum values of the graph ranges.\n"
           "@return Returns the minimum of the range formatted as \"x-min y-min\"")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }
   return object->getGraphMin(plotID);
}

DefineEngineMethod(GuiParticleGraphCtrl, getGraphMax, Point2F, (S32 plotID), , "(int plotID) "
           "Get the maximum values of the graph ranges.\n"
           "@return Returns the maximum of the range formatted as \"x-max y-max\"")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }
   return object->getGraphMax(plotID);
    
}

DefineEngineMethod(GuiParticleGraphCtrl, getGraphName, const char*, (S32 plotID), , "(int plotID) "
              "Get the name of the graph passed.\n"
           "@return Returns the name of the plot")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
   }

   const U32 bufSize = 64;
   char *retBuffer = Con::getReturnBuffer(bufSize);
   const StringTableEntry graphName = object->getGraphName(plotID);
   dSprintf(retBuffer, bufSize, "%s", graphName);
   return retBuffer;
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphMin, void, (S32 plotID, F32 minX, F32 minY), , "(int plotID, float minX, float minY) "
           "Set the min values of the graph of plotID.\n"
           "@param plotID The plot to modify\n"
           "@param minX,minY The minimum bound of the value range.\n"
           "@return No return value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphMin(plotID, Point2F(minX, minY));
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphMinX, void, (S32 plotID, F32 minX), , "(int plotID, float minX) "
           "Set the min X value of the graph of plotID.\n"
           "@param plotID The plot to modify.\n"
           "@param minX The minimum x value.\n"
           "@return No return Value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphMinX(plotID, minX);
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphMinY, void, (S32 plotID, F32 minX), , "(int plotID, float minY) "
           "Set the min Y value of the graph of plotID."
           "@param plotID The plot to modify.\n"
           "@param minY The minimum y value.\n"
           "@return No return Value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphMinY(plotID, minX);
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphMax, void, (S32 plotID, F32 maxX, F32 maxY), , "(int plotID, float maxX, float maxY) "
           "Set the max values of the graph of plotID."
           "@param plotID The plot to modify\n"
           "@param maxX,maxY The maximum bound of the value range.\n"
           "@return No return value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphMax(plotID, Point2F(maxX, maxY));
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphMaxX, void, (S32 plotID, F32 maxX), , "(int plotID, float maxX)"
           "Set the max X value of the graph of plotID."
           "@param plotID The plot to modify.\n"
           "@param maxX The maximum x value.\n"
           "@return No return Value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphMaxX(plotID, maxX);
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphMaxY, void, (S32 plotID, F32 maxX), , "(int plotID, float maxY)"
           "Set the max Y value of the graph of plotID."
           "@param plotID The plot to modify.\n"
           "@param maxY The maximum y value.\n"
           "@return No return Value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphMaxY(plotID, maxX);
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphHidden, void, (S32 plotID, bool isHidden), , "(int plotID, bool isHidden)"
           "Set whether the graph number passed is hidden or not."
           "@return No return value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphHidden(plotID, isHidden);
}

DefineEngineMethod(GuiParticleGraphCtrl, setAutoGraphMax, void, (bool autoMax), , "(bool autoMax) "
           "Set whether the max will automatically be set when adding points "
           "(ie if you add a value over the current max, the max is increased to that value).\n"
           "@return No return value.")
{
   object->setAutoGraphMax(autoMax);
}

DefineEngineMethod(GuiParticleGraphCtrl, setAutoRemove, void, (bool autoRemove), , "(bool autoRemove) "
           "Set whether or not a point should be deleted when you drag another one over it."
           "@return No return value.")
{
   object->setAutoRemove(autoRemove);
}

DefineEngineMethod(GuiParticleGraphCtrl, setRenderAll, void, (bool autoRemove), , "(bool renderAll)"
           "Set whether or not a position should be rendered on every point or just the last selected."
           "@return No return value.")
{
   object->setRenderAll(autoRemove);
}

DefineEngineMethod(GuiParticleGraphCtrl, setPointXMovementClamped, void, (bool autoRemove), , "(bool clamped)"
           "Set whether the x position of the selected graph point should be clamped"
           "@return No return value.")
{
   object->setPointXMovementClamped(autoRemove);
}

DefineEngineMethod(GuiParticleGraphCtrl, setRenderGraphTooltip, void, (bool autoRemove), , "(bool renderGraphTooltip)"
           "Set whether or not to render the graph tooltip."
           "@return No return value.")
{
   object->setRenderGraphTooltip(autoRemove);
}

DefineEngineMethod(GuiParticleGraphCtrl, setGraphName, void, (S32 plotID, const char * graphName), , "(int plotID, string graphName) "
           "Set the name of the given plot.\n"
           "@param plotID The plot to modify.\n"
           "@param graphName The name to set on the plot.\n"
           "@return No return value.")
{

   if(plotID >= object->MaxPlots)
   {
      Con::errorf("Invalid plotID.");
      return;
   }

   object->setGraphName(plotID, graphName);
}

DefineEngineMethod(GuiParticleGraphCtrl, resetSelectedPoint, void, (), , "()"
           "This will reset the currently selected point to nothing."
           "@return No return value.")
{
   object->resetSelectedPoint();
}