#include <remotepsapp/windowview.hpp>
#include <common/assert.hpp>
#include <common/string.hpp>

char WindowView::mszClassName[]="WINDOWVIEW";

WindowView::WindowView(void)
{
  mCreateHandler.setCallback(this,&WindowView::createHandler);
	mDestroyHandler.setCallback(this,&WindowView::destroyHandler);
	mCloseHandler.setCallback(this,&WindowView::closeHandler);
	mPaintHandler.setCallback(this,&WindowView::paintHandler);
	mSizeHandler.setCallback(this,&WindowView::sizeHandler);
	mVerticalScrollHandler.setCallback(this,&WindowView::verticalScrollHandler);
	mHorizontalScrollHandler.setCallback(this,&WindowView::horizontalScrollHandler);
	mEraseBackgroundHandler.setCallback(this,&WindowView::eraseBackgroundHandler);
  insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
  insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
  insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
  insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
	insertHandler(VectorHandler::VerticalScrollHandler,&mVerticalScrollHandler);
	insertHandler(VectorHandler::HorizontalScrollHandler,&mHorizontalScrollHandler);
	insertHandler(VectorHandler::EraseBackgroundHandler,&mEraseBackgroundHandler);
	registerClass();
}

WindowView::WindowView(const WindowView &someWindowView)
{
}

WindowView::~WindowView()
{
  removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
  removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
  removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
  removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
	removeHandler(VectorHandler::VerticalScrollHandler,&mVerticalScrollHandler);
	removeHandler(VectorHandler::HorizontalScrollHandler,&mHorizontalScrollHandler);
	removeHandler(VectorHandler::EraseBackgroundHandler,&mEraseBackgroundHandler);
}

WindowView &WindowView::operator=(const WindowView &/*someWindowView*/)
{ // private implemnentation
  return *this;
}

bool WindowView::create(GUIWindow &parentWindow,GUIWindow &conformParent,const Rect &winRect,UINT controlID)
{
  if(isValid())return false;
  createWindow(WS_EX_CLIENTEDGE,className(),className(),WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_VISIBLE,winRect,parentWindow,(HMENU)0,processInstance(),(LPSTR)this);
	assumeControl(conformParent,*this,0);
	update();
	return isValid();
}

void WindowView::registerClass(void)
{
  WNDCLASS wndClass;
	if(::GetClassInfo(processInstance(),className(),(WNDCLASS FAR*)&wndClass))return;
	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_OWNDC|CS_DBLCLKS;
	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
	wndClass.cbClsExtra    =0;
	wndClass.cbWndExtra    =sizeof(WindowView*);
	wndClass.hInstance     =processInstance();
  wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
	wndClass.hbrBackground =(HBRUSH)::GetStockObject(WHITE_BRUSH);
	wndClass.lpszMenuName  =0;
	wndClass.lpszClassName =className();
	::RegisterClass(&wndClass);
	assert(0!=::GetClassInfo(processInstance(),className(),(WNDCLASS FAR*)&wndClass));
}

CallbackData::ReturnType WindowView::createHandler(CallbackData &someCallbackData)
{
  mScrollInfo.hwndOwner(*this);
  return false;
}

CallbackData::ReturnType WindowView::destroyHandler(CallbackData &someCallbackData)
{
  return false;
}

CallbackData::ReturnType WindowView::closeHandler(CallbackData &someCallbackData)
{
  return false;
}

CallbackData::ReturnType WindowView::paintHandler(CallbackData &someCallbackData)
{
  if(!mJPGImage.isOkay())return false;
	PaintInformation *pPaintInfo=(PaintInformation*)someCallbackData.lParam();
	PureDevice &paintDevice=(PureDevice&)*pPaintInfo;
	if(mScrollInfo.sizeEvent())
	{
	  mScrollInfo.sizeEvent(false);
		mJPGImage.draw(paintDevice,Rect(0,0,mJPGImage.width(),mJPGImage.height()),Point(mScrollInfo.currScrollx(),mScrollInfo.currScrolly()));
	}
	if(mScrollInfo.scrollEvent()||(!mScrollInfo.sizeEvent()&&!mScrollInfo.scrollEvent()))
	{
	  Rect paintRect(pPaintInfo->paintRect());
	  mScrollInfo.scrollEvent(FALSE);
		paintRect.right(paintRect.right()-paintRect.left());
		paintRect.bottom(paintRect.bottom()-paintRect.top());
	  mJPGImage.draw(paintDevice,paintRect,Point(paintRect.left()+mScrollInfo.currScrollx(),paintRect.top()+mScrollInfo.currScrolly()));
	}
  return false;
}

CallbackData::ReturnType WindowView::sizeHandler(CallbackData &someCallbackData)
{
  mScrollInfo.handleSize(someCallbackData);
  return false;
}

CallbackData::ReturnType WindowView::verticalScrollHandler(CallbackData &someCallbackData)
{
	mScrollInfo.handleVerticalScroll(someCallbackData);
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType WindowView::horizontalScrollHandler(CallbackData &someCallbackData)
{
	mScrollInfo.handleHorizontalScroll(someCallbackData);
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType WindowView::eraseBackgroundHandler(CallbackData &someCallbackData)
{
  return (CallbackData::ReturnType)FALSE;
}

bool WindowView::createImage(const String &strPathFileName)
{
  if(!isValid())return false;
	PureDevice pureDevice(*this);
	mJPGImage.decode(strPathFileName,pureDevice);
	if(!mJPGImage.isOkay())return false;
  mScrollInfo.scrollableObjectDimensions(mJPGImage.width(),mJPGImage.height());
	invalidate();
	return true;
}