GuiBitmapSelCtrl

#ifndef _GUIBITMAPCTRL_H_
#define _GUIBITMAPCTRL_H_

#ifndef _GUICONTROL_H_
#include "gui/core/guiControl.h"
#endif
#ifndef _GUIMOUSEEVENTCTRL_H_
#include "gui/utility/guiMouseEventCtrl.h"
#endif

/// Renders a bitmap.
class GuiBitmapSelCtrl : public GuiControl
{
private:
   typedef GuiControl Parent;

protected:
   StringTableEntry mBitmapName;
   GFXTexHandle mTextureHandle;
   Point2I startPoint;
   bool mWrap;
   Point2I mousePos;
   bool mShowCursor;
   ColorI mCursorColor;
   F32 mCursorWidth;
   F32 mBoxSizeWidth;
   F32 mBoxSizeHeight;

public:
   //creation methods
   DECLARE_CONOBJECT(GuiBitmapSelCtrl);
   GuiBitmapSelCtrl();
   static void initPersistFields();

   //Parental methods
   bool onWake();
   void onSleep();
   void inspectPostApply();

   void onMouseDown(const GuiEvent &);
   void onMouseEnter(const GuiEvent & event);
   void onMouseLeave(const GuiEvent & event);
   void onMouseMove(const GuiEvent & event);
   void setBitmap(const char *name,bool resize = false);
   void setBitmap(const GFXTexHandle handle, bool resize = false);

   void updateSizing();

   void onRender(Point2I offset, const RectI &updateRect);
   void setValue(S32 x, S32 y);
};

#endif

#include "console/console.h"
#include "console/consoleTypes.h"
#include "gfx/gfxDevice.h"
#include "gui/core/guiCanvas.h"

#include "gui/controls/GuiBitmapSelCtrl.h"

IMPLEMENT_CONOBJECT(GuiBitmapSelCtrl);

GuiBitmapSelCtrl::GuiBitmapSelCtrl(void)
{
   mBitmapName = StringTable->insert("");
	startPoint.set(0, 0);
	mWrap = false;
	mCursorWidth = 1.0f;
	mCursorColor = ColorI(255,0,0,255);
    mBoxSizeWidth = 0;
    mBoxSizeHeight = 0;
}

void GuiBitmapSelCtrl::onMouseEnter(const GuiEvent & event)
{
	GuiCanvas* Canvas = getRoot();
	mShowCursor = false;
	Canvas->showCursor(false);
}

void GuiBitmapSelCtrl::onMouseLeave(const GuiEvent & event)
{
	GuiCanvas* Canvas = getRoot();
	mShowCursor = true;
    Canvas->showCursor(true);
}

void GuiBitmapSelCtrl::onMouseMove(const GuiEvent & event)
{
	mousePos.x = event.mousePoint.x;
	mousePos.y = event.mousePoint.y;
}

void GuiBitmapSelCtrl::onMouseDown(const GuiEvent &event)
{
   if (!mActive)
      return;
   
   Point2I curMousePos = globalToLocalCoord(event.mousePoint);

   Con::executef(this, "onMouseDown", Con::getIntArg(curMousePos.x), Con::getIntArg(curMousePos.y),
                 Con::getIntArg(getBounds().extent.x), Con::getIntArg(getBounds().extent.y));                               
}

void GuiBitmapSelCtrl::initPersistFields()
{
   Parent::initPersistFields();
   addGroup("Misc");		
   addField("bitmap", TypeFilename, Offset(mBitmapName, GuiBitmapSelCtrl));
   addField("wrap",   TypeBool,     Offset(mWrap,       GuiBitmapSelCtrl));
   addField("cursorColor",    TypeColorI,    Offset(mCursorColor, GuiBitmapSelCtrl));
   addField("cursorWidth",    TypeF32,    Offset(mCursorWidth, GuiBitmapSelCtrl));
   addField("boxSizeWidth",    TypeF32,    Offset(mBoxSizeWidth, GuiBitmapSelCtrl));
   addField("boxSizeHeight",    TypeF32,    Offset(mBoxSizeHeight, GuiBitmapSelCtrl));
   endGroup("Misc");		
}

ConsoleMethod( GuiBitmapSelCtrl, setValue, void, 4, 4, "(int xAxis, int yAxis)"
              "Set the offset of the bitmap.")
{
   object->setValue(dAtoi(argv[2]), dAtoi(argv[3]));
}

ConsoleMethod( GuiBitmapSelCtrl, setBitmap, void, 3, 3, "(string filename)"
              "Set the bitmap displayed in the control. Note that it is limited in size, to 256x256.")
{
   object->setBitmap(argv[2]);
}

bool GuiBitmapSelCtrl::onWake()
{
   if (! Parent::onWake())
      return false;
   setActive(true);
   setBitmap(mBitmapName);

   return true;
}

void GuiBitmapSelCtrl::onSleep()
{
   mTextureHandle = NULL;
   Parent::onSleep();
}

//-------------------------------------
void GuiBitmapSelCtrl::inspectPostApply()
{
   // if the extent is set to (0,0) in the gui editor and appy hit, this control will
   // set it's extent to be exactly the size of the bitmap (if present)
   Parent::inspectPostApply();

   if (!mWrap && (getExtent().x == 0) && (getExtent().y == 0) && mTextureHandle)
   {
      setExtent( mTextureHandle->getWidth(), mTextureHandle->getHeight());
   }
}

void GuiBitmapSelCtrl::setBitmap(const char *name, bool resize)
{
   mBitmapName = StringTable->insert(name);
   if (*mBitmapName) 
   {
      mTextureHandle.set( mBitmapName, &GFXDefaultGUIProfile );
      // Resize the control to fit the bitmap
      //if( mTextureHandle && resize )
      if( resize )
      {
         setExtent(mTextureHandle->getWidth(), mTextureHandle->getHeight());
         updateSizing();
      }
   
   }
   else
      mTextureHandle = NULL;
   setUpdate();
}
 
void GuiBitmapSelCtrl::setBitmap(GFXTexHandle handle, bool resize)
{
   mTextureHandle = handle;
   // Resize the control to fit the bitmap
   if (resize) 
   {
      setExtent(mTextureHandle->getWidth(), mTextureHandle->getHeight());
      updateSizing();
   }
}

void GuiBitmapSelCtrl::onRender(Point2I offset, const RectI &updateRect)
{
   if (mTextureHandle)
   {
	   GFX->getDrawUtil()->clearBitmapModulation();
		if(mWrap)
		{
 			GFXTextureObject* texture = mTextureHandle;
			RectI srcRegion;
			RectI dstRegion;
			float xdone = ((float)getExtent().x/(float)texture->mBitmapSize.x)+1;
			float ydone = ((float)getExtent().y/(float)texture->mBitmapSize.y)+1;

			int xshift = startPoint.x%texture->mBitmapSize.x;
			int yshift = startPoint.y%texture->mBitmapSize.y;
			for(int y = 0; y < ydone; ++y)
				for(int x = 0; x < xdone; ++x)
				{
		 			srcRegion.set(0,0,texture->mBitmapSize.x,texture->mBitmapSize.y);
  					dstRegion.set( ((texture->mBitmapSize.x*x)+offset.x)-xshift,
								      ((texture->mBitmapSize.y*y)+offset.y)-yshift,
								      texture->mBitmapSize.x,	
								      texture->mBitmapSize.y);
   				GFX->getDrawUtil()->drawBitmapStretchSR(texture,dstRegion, srcRegion);
				}
		}
		else
      {
        RectI rect(offset, getExtent());
        GFX->getDrawUtil()->drawBitmapStretch(mTextureHandle, rect);
      }
	  if(!mShowCursor)
	  {
       	  GFX->getDrawUtil()->drawLine(mousePos.x, offset.y, mousePos.x, mousePos.y-mBoxSizeHeight, mCursorColor);
              GFX->getDrawUtil()->drawLine(mousePos.x, mousePos.y+mBoxSizeHeight+mCursorWidth, mousePos.x, offset.y + getBounds().extent.y, mCursorColor); 
		  GFX->getDrawUtil()->drawLine(offset.x, mousePos.y, mousePos.x-mBoxSizeWidth, mousePos.y, mCursorColor);
		  GFX->getDrawUtil()->drawLine(mousePos.x+mBoxSizeWidth+mCursorWidth, mousePos.y, offset.x+getBounds().extent.x, mousePos.y, mCursorColor);
              Point2I minPoint = Point2I(mousePos.x-mBoxSizeWidth, mousePos.y-mBoxSizeHeight);
		  Point2I maxPoint = Point2I(mousePos.x+mBoxSizeWidth, mousePos.y+mBoxSizeHeight);
		  GFX->getDrawUtil()->drawRect(minPoint, maxPoint, mCursorColor);
	  }
   }
   if (mProfile->mBorder || !mTextureHandle)
   {
      RectI rect(offset.x, offset.y, getBounds().extent.x, getBounds().extent.y);
      GFX->getDrawUtil()->drawRect(rect, mProfile->mBorderColor);
   }
   renderChildControls(offset, updateRect);
}

void GuiBitmapSelCtrl::updateSizing()
{
   if(!getParent())
      return;
   // updates our bounds according to our horizSizing and verSizing rules
   RectI fakeBounds( getPosition(), getParent()->getExtent());
   parentResized( fakeBounds, fakeBounds);
}

void GuiBitmapSelCtrl::setValue(S32 x, S32 y)
{
   if (mTextureHandle)
   {
		GFXTextureObject* texture = mTextureHandle;
            x+=texture->getWidth()/2;
		y+=texture->getHeight()/2;
  	}
  	while (x < 0)
  		x += 256;
  	startPoint.x = x % 256;
  				
  	while (y < 0)
  		y += 256;
  	startPoint.y = y % 256;
}