root/week1oplossing/GameEngine.cpp

//-----------------------------------------------------------------
// Game Engine Object
// C++ Source - GameEngine.cpp - version 2008 v3_02
// Copyright Kevin Hoefman - kevin.hoefman@howest.be
// http://www.digitalartsandentertainment.be/
//-----------------------------------------------------------------

//-----------------------------------------------------------------
// Include Files
//-----------------------------------------------------------------
#include "GameEngine.h"

#define _USE_MATH_DEFINES       // necessary for including (among other values) PI  - see math.h
#include <math.h>                       // used in various draw methods
#include <stdio.h>
#include <tchar.h>                      // used for unicode strings

#include <memory.h>
#include <vector>                       // using std::vector for tab control logic

//-----------------------------------------------------------------
// Static Variable Initialization
//-----------------------------------------------------------------
GameEngine* GameEngine::m_GameEnginePtr = NULL;

//-----------------------------------------------------------------
// Windows Functions
//-----------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWindow, UINT msg, WPARAM wParam, LPARAM lParam)
{
        // Route all Windows messages to the game engine
        return GameEngine::GetSingleton()->HandleEvent(hWindow, msg, wParam, lParam);
}

DWORD WINAPI KeybThreadProc(GameEngine* gamePtr)
{
        return gamePtr->KeybThreadProc();
}

//-----------------------------------------------------------------
// GameEngine Constructor(s)/Destructor
//-----------------------------------------------------------------
GameEngine::GameEngine() :      m_hInstance(NULL), 
                                                        m_hWindow(NULL),
                                                        m_TitlePtr(0),
                                                        m_iFrameDelay(50),              // 20 FPS default
                                                        m_bSleep(true), 
                                                        m_bRunGameLoop(false),
                                                        m_bKeybRunning(true),   // create the keyboard monitoring thread
                                                        m_KeyListPtr(NULL),
                                                        m_KeybMonitor(0x0),             // binary ; 0 = key not pressed, 1 = key pressed
                                                        m_isPainting(false),
                                                        m_isDoublebuffering(false),
                                                        m_colDraw(RGB(0,0,0)),
                                                        m_FontDraw(0),
                                                        m_GamePtr(0),
                                                        m_PaintDoublebuffered(false),
                                                        m_Fullscreen(false),
                                                        m_WindowRegionPtr(0)
{
        m_hKeybThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE) ::KeybThreadProc, this, NULL, &m_dKeybThreadID);
}

GameEngine::~GameEngine()
{
        // Clean up the keyboard monitoring thread
        m_bKeybRunning = false;
        WaitForSingleObject( m_hKeybThread, INFINITE );
        CloseHandle( m_hKeybThread );   
        
        // clean up keyboard monitor buffer after the thread that uses it is closed
        if (m_KeyListPtr != 0) 
        {
                delete m_KeyListPtr;
                m_KeyListPtr = 0;
        }

        // clean up the font
        if (m_FontDraw != 0) 
        {
                DeleteObject(m_FontDraw);
                m_FontDraw = 0;
        }

        // clean up the AbstractGame object
        delete m_GamePtr;
}

//-----------------------------------------------------------------
// Game Engine Static Methods
//-----------------------------------------------------------------

GameEngine* GameEngine::GetSingleton()
{
        if ( m_GameEnginePtr == NULL) m_GameEnginePtr = new GameEngine();
        return m_GameEnginePtr;
}

void GameEngine::SetGame(AbstractGame* gamePtr)
{
        m_GamePtr = gamePtr;
}

DWORD GameEngine::KeybThreadProc()
{
        while (m_bKeybRunning)
        {
                if (m_KeyListPtr != NULL)
                {
                        int count = 0;
                        int key = m_KeyListPtr[0];

                        while (key != '\0' && count < (8 * sizeof(unsigned int)))
                        {       
                                if ( !(GetAsyncKeyState(key)<0) ) // key is not pressed
                                {           
                                        if (m_KeybMonitor & (0x1 << count)) {
                                                m_GamePtr->KeyPressed(key); // als de bit op 1 stond, dan firet dit een keypress
                                        }
                                        m_KeybMonitor &= ~(0x1 << count);   // de bit wordt op 0 gezet: key is not pressed
                                }
                                else m_KeybMonitor |= (0x1 << count);   // de bit wordt op 1 gezet: key is pressed

                                key = m_KeyListPtr[++count]; // increase count and get next key
                        }
                }       

                Sleep(1000 / KEYBCHECKRATE);
        }
        return 0;
}

//-----------------------------------------------------------------
// Game Engine General Methods
//-----------------------------------------------------------------

void GameEngine::SetTitle(const tstring& titleRef)
{
        delete m_TitlePtr; // delete the title string if it already exists
        m_TitlePtr = new tstring(titleRef);
}

bool GameEngine::Run(HINSTANCE hInstance, int iCmdShow)
{
        MSG msg;
        int iTickTrigger = 0;
        int iTickCount;

        // create the game engine object, exit if failure
        if (GameEngine::GetSingleton() == NULL) return false;

        // set the instance member variable of the game engine
        GameEngine::GetSingleton()->SetInstance(hInstance);

        // Game Initialization
        m_GamePtr->GameInitialize(hInstance);

        // Initialize the game engine
        if (!GameEngine::GetSingleton()->ClassRegister(iCmdShow)) return false;

        // Attach the keyboard thread to the main thread. This gives the keyboard events access to the window state
        // In plain English: this allows a KeyPressed() event to hide the cursor of the window. 
        AttachThreadInput(m_dKeybThreadID, GetCurrentThreadId(), true);

        // Enter the main message loop
        while (true)
        {
                if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
                {
                        // Process the message
                        if (msg.message == WM_QUIT) break;
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                }
                else
                {
                        // Make sure the game engine isn't sleeping
                        if (!GameEngine::GetSingleton()->GetSleep() && m_bRunGameLoop)
                        {
                                // Check the tick count to see if a game cycle has elapsed
                                iTickCount = GetTickCount();
                                if (iTickCount > iTickTrigger)
                                {
                                        iTickTrigger = iTickCount + GameEngine::GetSingleton()->GetFrameDelay();

                                        // Do user defined keyboard check
                                        m_GamePtr->CheckKeyboard();

                                        // Get window, rectangle and HDC
                                        HWND hWindow = GetWindow();
                                        RECT rect;
                                        HDC hDC = GetDC(hWindow);
                                        GetClientRect(hWindow, &rect);

                                        // Double buffering code
                                        HDC hBufferDC = CreateCompatibleDC(hDC);
                                        int iWidth = GetWidth();
                                        int iHeight = GetHeight();
                                        // Create the buffer
                                        HBITMAP hBufferBmp = CreateCompatibleBitmap(hDC, iWidth, iHeight);
                                        HBITMAP hOldBmp = (HBITMAP) SelectObject(hBufferDC, hBufferBmp);

                                        // Do user defined drawing functions on the buffer, parameters added
                                        // for ease of drawing
                                        m_HdcDraw = hBufferDC;
                                        m_RectDraw = rect;
                                        m_isDoublebuffering = true;
                                        m_GamePtr->GameCycle(rect);
                                        m_isDoublebuffering = false;

                                        // As a last step copy the memdc to the hdc
                                        BitBlt(hDC, 0, 0, iWidth, iHeight, hBufferDC, 0, 0, SRCCOPY);

                                        // Reset the old bmp of the buffer, mainly for show since we kill it anyway
                                        SelectObject(hBufferDC, hOldBmp);
                                        // Kill the buffer
                                        DeleteObject(hBufferBmp);
                                        DeleteDC(hBufferDC);

                                        // Release HDC
                                        ReleaseDC(hWindow, hDC);
                                }                             
                                else Sleep(1);//Sleep for one ms te bring cpu load from 100% to 1%. if removed this loops like roadrunner
                        }
                        else WaitMessage(); // if the engine is sleeping or the game loop isn't supposed to run, wait for the next windows message.
                }
        }
        return msg.wParam?true:false;
}

bool GameEngine::SetGameValues(const tstring& titleRef, WORD wIcon, WORD wSmallIcon, int iWidth = 640, int iHeight = 480)
{
        SetTitle(titleRef);
        SetIcon(wIcon);
        SetSmallIcon(wSmallIcon);
        SetWidth(iWidth);
        SetHeight(iHeight);

        return true;
}

void GameEngine::ShowMousePointer(bool value) const
{
        // set the value
        ShowCursor(value);      
        
        // redraw the screen
        InvalidateRect(m_hWindow, 0, true);
}

bool GameEngine::SetWindowRegion(const HitRegion* regionPtr)
{
        if (m_Fullscreen) return false;

        if (regionPtr == 0) 
        {       
                // turn off window region
                SetWindowRgn(m_hWindow, 0, true);

                // delete the buffered window region (if it exists)
                delete m_WindowRegionPtr;
                m_WindowRegionPtr = 0;
        }
        else 
        {
                // if there is already a window region set, release the buffered region object
                if (m_WindowRegionPtr != 0)
                {
                        // turn off window region for safety
                        SetWindowRgn(m_hWindow, 0, true);
                                
                        // delete the buffered window region 
                        delete m_WindowRegionPtr;
                        m_WindowRegionPtr = 0;
                }

                // create a copy of the submitted region (windows will lock the region handle that it receives)
                m_WindowRegionPtr = regionPtr->Clone();

                // translate region coordinates in the client field to window coordinates, taking title bar and frame into account
                m_WindowRegionPtr->Move(GetSystemMetrics(SM_CXFIXEDFRAME), GetSystemMetrics(SM_CYFIXEDFRAME) + GetSystemMetrics(SM_CYCAPTION));

                // set the window region
                SetWindowRgn(m_hWindow, m_WindowRegionPtr->GetHandle(), true);
        }

        return true;
}

bool GameEngine::HasWindowRegion() const
{
        return (m_WindowRegionPtr?true:false);
}

bool GameEngine::GoFullscreen()
{
        // exit if already in fullscreen mode
        if (m_Fullscreen) return false;

        // turn off window region without redraw
        SetWindowRgn(m_hWindow, 0, false);

        DEVMODE newSettings;    

        // request current screen settings
        EnumDisplaySettings(0, 0, &newSettings);

        //  set desired screen size/res 
        newSettings.dmPelsWidth  = GetWidth();          
        newSettings.dmPelsHeight = GetHeight();         
        newSettings.dmBitsPerPel = 32;          

        //specify which aspects of the screen settings we wish to change 
        newSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        // attempt to apply the new settings 
        long result = ChangeDisplaySettings(&newSettings, CDS_FULLSCREEN);

        // exit if failure, else set datamember to fullscreen and return true
        if ( result != DISP_CHANGE_SUCCESSFUL ) return false;
        else 
        {
                // store the location of the window
                m_oldLoc = GetLocation();

                // switch off the title bar
            DWORD dwStyle = GetWindowLong(m_hWindow, GWL_STYLE);
            dwStyle &= ~WS_CAPTION;
            SetWindowLong(m_hWindow, GWL_STYLE, dwStyle);

                // move the window to (0,0)
                SetWindowPos(m_hWindow, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
                InvalidateRect(m_hWindow, 0, true);             

                m_Fullscreen = true;

                return true;
        }
}

bool GameEngine::GoWindowedMode()
{
        // exit if already in windowed mode
        if (!m_Fullscreen) return false;

        // this resets the screen to the registry-stored values
        ChangeDisplaySettings(0, 0);

        // replace the title bar
        DWORD dwStyle = GetWindowLong(m_hWindow, GWL_STYLE);
    dwStyle = dwStyle | WS_CAPTION;
    SetWindowLong(m_hWindow, GWL_STYLE, dwStyle);

        // move the window back to its old position
        SetWindowPos(m_hWindow, 0, m_oldLoc.x, m_oldLoc.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
        InvalidateRect(m_hWindow, 0, true);

        m_Fullscreen = false;

        return true;
}

bool GameEngine::IsFullscreen() const
{
        return m_Fullscreen;
}

bool GameEngine::ClassRegister(int iCmdShow)
{
  WNDCLASSEX    wndclass;

  // Create the window class for the main window
  wndclass.cbSize         = sizeof(wndclass);
  wndclass.style          = CS_HREDRAW | CS_VREDRAW;
  wndclass.lpfnWndProc    = WndProc;
  wndclass.cbClsExtra     = 0;
  wndclass.cbWndExtra     = 0;
  wndclass.hInstance      = m_hInstance;
  wndclass.hIcon          = LoadIcon(m_hInstance, MAKEINTRESOURCE(GetIcon()));
  wndclass.hIconSm        = LoadIcon(m_hInstance, MAKEINTRESOURCE(GetSmallIcon()));
  wndclass.hCursor        = LoadCursor(NULL, IDC_ARROW);
  wndclass.hbrBackground  = m_PaintDoublebuffered?NULL:(HBRUSH)(COLOR_WINDOW + 1);
  wndclass.lpszMenuName   = NULL;
  wndclass.lpszClassName  = m_TitlePtr->c_str();

  // Register the window class
  if (!RegisterClassEx(&wndclass))
    return false;

  // Calculate the window size and position based upon the game size
  int iWindowWidth = m_iWidth + GetSystemMetrics(SM_CXFIXEDFRAME) * 2,
      iWindowHeight = m_iHeight + GetSystemMetrics(SM_CYFIXEDFRAME) * 2 +
        GetSystemMetrics(SM_CYCAPTION);
  if (wndclass.lpszMenuName != NULL)
    iWindowHeight += GetSystemMetrics(SM_CYMENU);
  int iXWindowPos = (GetSystemMetrics(SM_CXSCREEN) - iWindowWidth) / 2,
      iYWindowPos = (GetSystemMetrics(SM_CYSCREEN) - iWindowHeight) / 2;

  // Create the window
  m_hWindow = CreateWindow(     m_TitlePtr->c_str(), 
                                                        m_TitlePtr->c_str(), 
                                                        WS_POPUPWINDOW | WS_CAPTION | WS_MINIMIZEBOX | WS_CLIPCHILDREN, 
                                                        iXWindowPos, 
                                                        iYWindowPos, 
                                                        iWindowWidth, 
                                                        iWindowHeight, 
                                                        NULL, 
                                                        NULL, 
                                                        m_hInstance, 
                                                        NULL);
  if (!m_hWindow)
    return false;

  // Show and update the window
  ShowWindow(m_hWindow, iCmdShow);
  UpdateWindow(m_hWindow);

  return true;
}

bool GameEngine::IsKeyDown(int vKey) const
{
        if (GetAsyncKeyState(vKey) < 0) return true;
        else return false;
}

void GameEngine::SetKeyList(const tstring& keyListRef)
{
        if (keyListRef.c_str() != NULL) delete m_KeyListPtr; // clear lijst als er al een lijst bestaat

        /*
        int iLength = 0;

        while (keyListRef.c_str()[iLength] != '\0') iLength++; // tellen hoeveel tekens er zijn
        */

        m_KeyListPtr = (TCHAR*) malloc((keyListRef.size() + 1) * sizeof(TCHAR)); // maak plaats voor zoveel tekens + 1 

        for (int count = 0; count < (int) keyListRef.size() + 1; ++count) 
        {
                TCHAR key = keyListRef.c_str()[count]; 
                m_KeyListPtr[count] = (key > 96 && key < 123)? key-32 : key; // vul het teken in, in uppercase indien kleine letter
        }
}

void GameEngine::QuitGame() const
{
        PostMessage(GameEngine::GetWindow(), WM_DESTROY, 0, 0);
}

void GameEngine::MessageBox(const tstring& textRef) const
{
        #ifdef UNICODE                                          // MessageBox define is undef'd at begin of GameEngine.h
        #define MessageBox  MessageBoxW         // but is needed here
        #else
        #define MessageBox  MessageBoxA
        #endif 

        MessageBox(GetWindow(), textRef.c_str(), m_TitlePtr->c_str(), MB_ICONEXCLAMATION | MB_OK);

        #undef  MessageBox                                      // undefining it again
}

void GameEngine::MessageBox(int value) const
{
        tstringstream buffer;
        buffer << value;

        MessageBox(buffer.str());
}

void GameEngine::MessageBox(size_t value) const
{
        tstringstream buffer;
        buffer << value;

        MessageBox(buffer.str());
}

void GameEngine::MessageBox(double value) const
{
        tstringstream buffer;
        buffer << value;

        MessageBox(buffer.str());
}

static bool CALLBACK EnumInsertChildrenProc(HWND hwnd, LPARAM lParam)
{
        std::vector<HWND> *row = (std::vector<HWND> *) lParam; // std::vector niet te kennen 1e jaar DAE

        row->push_back(hwnd); // elk element invullen in de vector

        return true;
}

void GameEngine::TabNext(HWND ChildWindow) const
{
        std::vector<HWND> childWindows; // std::vector niet te kennen 1e jaar DAE

        EnumChildWindows(m_hWindow, (WNDENUMPROC) EnumInsertChildrenProc, (LPARAM) &childWindows);

        int position = 0;
        HWND temp = childWindows[position];
        while(temp != ChildWindow) temp = childWindows[++position]; // positie van childWindow in de vector opzoeken 

        if (position == childWindows.size() - 1) SetFocus(childWindows[0]);
        else SetFocus(childWindows[position + 1]);
}

void GameEngine::TabPrevious(HWND ChildWindow) const
{       
        std::vector<HWND> childWindows; 

        EnumChildWindows(m_hWindow, (WNDENUMPROC) EnumInsertChildrenProc, (LPARAM) &childWindows);

        int position = (int) childWindows.size() - 1;
        HWND temp = childWindows[position];
        while(temp != ChildWindow) temp = childWindows[--position]; // positie van childWindow in de vector opzoeken 

        if (position == 0) SetFocus(childWindows[childWindows.size() - 1]);
        else SetFocus(childWindows[position - 1]);
}

bool GameEngine::DrawLine(int x1, int y1, int x2, int y2, HDC hDC) const
{
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        MoveToEx(hDC, x1, y1, NULL);
        LineTo(hDC, x2, y2);
        MoveToEx(hDC, 0, 0, NULL); // reset van de positie - zorgt ervoor dat bvb AngleArc vanaf 0,0 gaat tekenen ipv de laatste positie van de DrawLine
        SelectObject(hDC, hOldPen);
        DeleteObject(hNewPen);
        
        return true;
}

bool GameEngine::DrawLine(int x1, int y1, int x2, int y2) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawLine(x1, y1, x2, y2, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawPolygon(const POINT ptsArr[], int count, bool close, HDC hDC) const
{
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);

        FormPolygon(ptsArr, count, close, hDC);

        SelectObject(hDC, hOldPen);
        DeleteObject(hNewPen);  

        return true;
}

bool GameEngine::DrawPolygon(const POINT ptsArr[], int count, bool close) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawPolygon(ptsArr, count, close, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawPolygon(const POINT ptsArr[], int count) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawPolygon(ptsArr, count, false, m_HdcDraw);
        else return false;
}

bool GameEngine::FillPolygon(const POINT ptsArr[], int count, bool close, HDC hDC) const
{
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
        HBRUSH hOldBrush, hNewBrush = CreateSolidBrush(m_colDraw);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        hOldBrush = (HBRUSH) SelectObject(hDC, hNewBrush);

        BeginPath(hDC);

        FormPolygon(ptsArr, count, close, hDC);

        EndPath(hDC);
        StrokeAndFillPath(hDC);

        SelectObject(hDC, hOldPen);
        SelectObject(hDC, hOldBrush);

        DeleteObject(hNewPen);
        DeleteObject(hNewBrush);

        return true;
}

bool GameEngine::FillPolygon(const POINT ptsArr[], int count, bool close) const
{
        if (m_isDoublebuffering || m_isPainting) return FillPolygon(ptsArr, count, close, m_HdcDraw);
        else return false;
}

bool GameEngine::FillPolygon(const POINT ptsArr[], int count) const
{
        if (m_isDoublebuffering || m_isPainting) return FillPolygon(ptsArr, count, false, m_HdcDraw);
        else return false;
}

void GameEngine::FormPolygon(const POINT ptsArr[], int count, bool close, HDC hDC) const
{
        if (!close) Polyline(hDC, ptsArr, count);
        else
        {
                POINT* newPtsArr= new POINT[count+1]; // interessant geval: deze code werkt niet met memory allocation at compile time => demo case for dynamic memory use
                for (int i = 0; i < count; i++) newPtsArr[i] = ptsArr[i];
                newPtsArr[count] = ptsArr[0];

                Polyline(hDC, newPtsArr, count+1);

                delete[] newPtsArr;
        }
}

bool GameEngine::DrawRect(int x, int y, int width, int height, HDC hDC) const
{
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        
        POINT pts[4] = {x, y, x + width -1, y, x + width-1, y + height-1, x, y + height-1};
        DrawPolygon(pts, 4, true, hDC);

        SelectObject(hDC, hOldPen);
        DeleteObject(hNewPen);  

        return true;
}

bool GameEngine::DrawRect(int x, int y, int width, int height) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawRect(x, y, width, height, m_HdcDraw);
        else return false;
}

bool GameEngine::FillRect(int x, int y, int width, int height, HDC hDC) const
{
        HBRUSH hOldBrush, hNewBrush = CreateSolidBrush(m_colDraw);
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);

        hOldBrush = (HBRUSH) SelectObject(hDC, hNewBrush);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        
        Rectangle(hDC, x, y, x + width, y + height);
                                                
        SelectObject(hDC, hOldPen);
        SelectObject(hDC, hOldBrush);

        DeleteObject(hNewPen);
        DeleteObject(hNewBrush);

        return true;
}

bool GameEngine::FillRect(int x, int y, int width, int height) const
{
        if (m_isDoublebuffering || m_isPainting) return FillRect(x, y, width, height, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawRoundRect(int x, int y, int width, int height, int radius, HDC hDC) const
{
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        
        BeginPath(hDC);

        RoundRect(hDC, x, y, x + width, y + height, radius, radius);

        EndPath(hDC);
        StrokePath(hDC);

        SelectObject(hDC, hOldPen);
        DeleteObject(hNewPen);  

        return true;
}

bool GameEngine::DrawRoundRect(int x, int y, int width, int height, int radius) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawRoundRect(x, y, width, height, radius, m_HdcDraw);
        else return false;
}

bool GameEngine::FillRoundRect(int x, int y, int width, int height, int radius, HDC hDC) const
{
        HBRUSH hOldBrush, hNewBrush = CreateSolidBrush(m_colDraw);
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);

        hOldBrush = (HBRUSH) SelectObject(hDC, hNewBrush);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        
        RoundRect(hDC, x, y, x + width, y + height, radius, radius);
                                                
        SelectObject(hDC, hOldPen);
        SelectObject(hDC, hOldBrush);

        DeleteObject(hNewPen);
        DeleteObject(hNewBrush);

        return true;
}

bool GameEngine::FillRoundRect(int x, int y, int width, int height, int radius) const
{
        if (m_isDoublebuffering || m_isPainting) return FillRoundRect(x, y, width, height, radius, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawOval(int x, int y, int width, int height, HDC hDC) const
{
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        
        Arc(hDC, x, y, x + width, y + height, x, y + height/2, x, y + height/2);

        SelectObject(hDC, hOldPen);
        DeleteObject(hNewPen);  

        return true;
}

bool GameEngine::DrawOval(int x, int y, int width, int height) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawOval(x, y, width, height, m_HdcDraw);
        else return false;
}

bool GameEngine::FillOval(int x, int y, int width, int height, HDC hDC) const
{
        HBRUSH hOldBrush, hNewBrush = CreateSolidBrush(m_colDraw);
        HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);

        hOldBrush = (HBRUSH) SelectObject(hDC, hNewBrush);
        hOldPen = (HPEN) SelectObject(hDC, hNewPen);
        
        Ellipse(hDC, x, y, x + width, y + height);
                                                
        SelectObject(hDC, hOldPen);
        SelectObject(hDC, hOldBrush);

        DeleteObject(hNewPen);
        DeleteObject(hNewBrush);

        return true;
}

bool GameEngine::FillOval(int x, int y, int width, int height) const
{
        if (m_isDoublebuffering || m_isPainting) return FillOval(x, y, width, height, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawArc(int x, int y, int width, int height, int startDegree, int angle, HDC hDC) const
{
        if (angle == 0) return false;
        if (angle > 360) { DrawOval(x, y, width, height, hDC); }
        else
        {
                HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);
                hOldPen = (HPEN) SelectObject(hDC, hNewPen);
                
                POINT ptStart = AngleToPoint(x, y, width, height, startDegree);
                POINT ptEnd = AngleToPoint(x, y, width, height, startDegree + angle);
                
                if (angle > 0) Arc(hDC, x, y, x + width, y + height, ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
                else Arc(hDC, x, y, x + width, y + height, ptEnd.x, ptEnd.y, ptStart.x, ptStart.y);

                SelectObject(hDC, hOldPen);
                DeleteObject(hNewPen);  
        }

        return true;
}

bool GameEngine::DrawArc(int x, int y, int width, int height, int startDegree, int angle) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawArc(x, y, width, height, startDegree, angle, m_HdcDraw);
        else return false;
}

bool GameEngine::FillArc(int x, int y, int width, int height, int startDegree, int angle, HDC hDC) const
{       
        if (angle == 0) return false;
        if (angle > 360) { FillOval(x, y, width, height, hDC); }
        else
        {
                HBRUSH hOldBrush, hNewBrush = CreateSolidBrush(m_colDraw);
                HPEN hOldPen, hNewPen = CreatePen(PS_SOLID, 1, m_colDraw);

                hOldBrush = (HBRUSH) SelectObject(hDC, hNewBrush);
                hOldPen = (HPEN) SelectObject(hDC, hNewPen);

                POINT ptStart = AngleToPoint(x, y, width, height, startDegree);
                POINT ptEnd = AngleToPoint(x, y, width, height, startDegree + angle);
                
                if (angle >0) Pie(hDC, x, y, x + width, y + height, ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
                else Pie(hDC, x, y, x + width, y + height, ptEnd.x, ptEnd.y, ptStart.x, ptStart.y);

                SelectObject(hDC, hOldPen);
                SelectObject(hDC, hOldBrush);

                DeleteObject(hNewPen);
                DeleteObject(hNewBrush);
        }

        return true;
}


bool GameEngine::FillArc(int x, int y, int width, int height, int startDegree, int angle) const
{
        if (m_isDoublebuffering || m_isPainting) return FillArc(x, y, width, height, startDegree, angle, m_HdcDraw);
        else return false;
}

POINT GameEngine::AngleToPoint(int x, int y, int width, int height, int angle) const
{
        POINT pt;

        // if necessary adjust angle so that it has a value between 0 and 360 degrees
        if (angle > 360 || angle < -360) angle = angle % 360;
        if (angle < 0) angle += 360;

        // default values for standard angles
        if (angle == 0) { pt.x = x + width; pt.y = y + (int) (height / 2); }
        else if (angle == 90) { pt.x = x + (int) (width / 2); pt.y = y; }
        else if (angle == 180) { pt.x = x; pt.y = y + (int) (height / 2); }
        else if (angle == 270) { pt.x = x + (int) (width / 2); pt.y = y + height; }
        // else calculate non-default values
        else
        {
                // point on the ellipse = "stelsel" of the cartesian equation of the ellipse combined with y = tg(alpha) * x
                // using the equation for ellipse with 0,0 in the center of the ellipse
                double aSquare = pow(width/2.0, 2);
                double bSquare = pow(height/2.0, 2);
                double tangens = tan(angle * M_PI / 180);
                double tanSquare = pow(tangens, 2);

                // calculate x
                pt.x = (long) sqrt( aSquare * bSquare / (bSquare + tanSquare * aSquare));
                if (angle > 90 && angle < 270) pt.x *= -1; // sqrt returns the positive value of the square, take the negative value if necessary

                // calculate y
                pt.y = (long) (tangens * pt.x);
                pt.y *= -1;     // reverse the sign because of inverted y-axis

                // offset the ellipse into the screen
                pt.x += x + (int)(width / 2);
                pt.y += y + (int)(height / 2);
        }

        return pt;
}

int GameEngine::DrawString(const tstring& textRef, int x, int y, int width, int height, HDC hDC) const
{
        HFONT hOldFont;
        COLORREF oldColor;

        if (m_FontDraw != 0) hOldFont = (HFONT) SelectObject(hDC, m_FontDraw);

        oldColor = SetTextColor(hDC, m_colDraw);
        SetBkMode(hDC, TRANSPARENT);
        
        RECT rc = {x, y, x + width - 1, y + height - 1};
        int result = DrawText(hDC, textRef.c_str(), -1, &rc, DT_WORDBREAK);

        SetBkMode(hDC, OPAQUE);
        SetTextColor(hDC, oldColor);
        if (m_FontDraw != 0) SelectObject(hDC, hOldFont);

        return result;
}

int GameEngine::DrawString(const tstring& textRef, int x, int y, int width, int height) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawString(textRef, x, y, width, height, m_HdcDraw);
        else return -1;
}

int GameEngine::DrawString(const tstring& textRef, int x, int y, HDC hDC) const
{
        HFONT hOldFont;
        COLORREF oldColor;

        if (m_FontDraw != 0) hOldFont = (HFONT) SelectObject(hDC, m_FontDraw);
        
        oldColor = SetTextColor(hDC, m_colDraw);
        SetBkMode(hDC, TRANSPARENT);

        /*
        int count = 0;
        while (textRef.c_str()[count] != '\0') count++;
        */

        int result = TextOut(hDC, x, y, textRef.c_str(), (int) textRef.size());

        SetBkMode(hDC, OPAQUE);
        SetTextColor(hDC, oldColor);

        if (m_FontDraw != 0) SelectObject(hDC, hOldFont);

        return result;
}

int GameEngine::DrawString(const tstring& textRef, int x, int y) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawString(textRef, x, y, m_HdcDraw);
        else return -1;
}

bool GameEngine::DrawBitmap(Bitmap* bitmapPtr, int x, int y, RECT rect, HDC hDC) const
{
        if (!bitmapPtr->Exists()) return false;

        int opacity = bitmapPtr->GetOpacity();

        if (opacity == 0 && bitmapPtr->HasAlphaChannel()) return true; // don't draw if opacity == 0 and opacity is used

        HDC hdcMem = CreateCompatibleDC(hDC);
        HBITMAP hbmOld = (HBITMAP) SelectObject(hdcMem, bitmapPtr->GetHandle());

        if (bitmapPtr->HasAlphaChannel())
        {
                BLENDFUNCTION blender={AC_SRC_OVER, 0, (int) (2.55 * opacity), AC_SRC_ALPHA}; // blend function combines opacity and pixel based transparency
                AlphaBlend(hDC, x, y, rect.right - rect.left, rect.bottom - rect.top, hdcMem, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, blender);
        }
        else TransparentBlt(hDC, x, y, rect.right - rect.left, rect.bottom - rect.top, hdcMem, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, bitmapPtr->GetTransparencyColor());

        SelectObject(hdcMem, hbmOld);
        DeleteDC(hdcMem);

        return true;
}

bool GameEngine::DrawBitmap(Bitmap* bitmapPtr, int x, int y, RECT rect) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawBitmap(bitmapPtr, x, y, rect, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawBitmap(Bitmap* bitmapPtr, int x, int y, HDC hDC) const
{
        if (!bitmapPtr->Exists()) return false;

    BITMAP bm;
    GetObject(bitmapPtr->GetHandle(), sizeof(bm), &bm);
        RECT rect = {0, 0, bm.bmWidth, bm.bmHeight};

    return DrawBitmap(bitmapPtr, x, y, rect, hDC);
}

bool GameEngine::DrawBitmap(Bitmap* bitmapPtr, int x, int y) const
{
        if (m_isDoublebuffering || m_isPainting) return DrawBitmap(bitmapPtr, x, y, m_HdcDraw);
        else return false;
}

bool GameEngine::DrawSolidBackground(COLORREF color, HDC hDC, RECT rect)
{
        COLORREF oldColor = GetDrawColor();
        SetColor(color);
        FillRect(0, 0, rect.right, rect.bottom, hDC);
        SetColor(oldColor);

        return true;
}

bool GameEngine::DrawSolidBackground(COLORREF color)
{       
        if (m_isDoublebuffering || m_isPainting) return DrawSolidBackground(color, m_HdcDraw, m_RectDraw);
        else return false;
}

bool GameEngine::Repaint() const
{
        return InvalidateRect(m_hWindow, NULL, true)?true:false;
}

POINT GameEngine::GetLocation() const
{
        RECT info;
        POINT pos;

        GetWindowRect(m_hWindow, &info);
        pos.x = info.left;
        pos.y = info.top;

        return pos;
}

void GameEngine::SetLocation(int x, int y)
{
        SetWindowPos(m_hWindow, 0, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
        InvalidateRect(m_hWindow, 0, TRUE);
}

void GameEngine::SetFont(const tstring& fontNameRef, bool bold, bool italic, bool underline, int size)
{
        if (m_FontDraw != 0) DeleteObject(m_FontDraw);

        LOGFONT ft;
        ZeroMemory(&ft, sizeof(ft));

        //_tcscpy_s(ft.lfFaceName, sizeof(ft.lfFaceName) / sizeof(TCHAR), fontName.c_str());
        for (int teller = 0; teller < (int) fontNameRef.size() && teller < LF_FACESIZE; ++teller)
        {
                ft.lfFaceName[teller] = fontNameRef[teller];
        }

        ft.lfStrikeOut = 0;
        ft.lfUnderline = underline?1:0;
        ft.lfHeight = size;
    ft.lfEscapement = 0;
        ft.lfWeight = bold?FW_BOLD:0;
        ft.lfItalic = italic?1:0;

    m_FontDraw = CreateFontIndirect(&ft);
}

void GameEngine::RunGameLoop(bool value)
{
        m_bRunGameLoop = value;
}

LRESULT GameEngine::HandleEvent(HWND hWindow, UINT msg, WPARAM wParam, LPARAM lParam)
{
        RECT rect;
        HDC         hDC;
        PAINTSTRUCT ps;

//                              HWND hWindow;
//                      RECT rect;
//                      HDC hDC;

                        // Double buffering code
                        HDC hBufferDC;
                        HBITMAP hBufferBmp;
                        HBITMAP hOldBmp;

                        int iWidth, iHeight;
                        static int count = 0;

        // Route Windows messages to game engine member functions
        switch (msg)
        {
                case WM_CREATE:
                        // Set the game window and start the game
                        SetWindow(hWindow);
                        // User defined functions for start of the game
                        m_GamePtr->GameStart();  
                        // Seed the random number generator
                        srand(GetTickCount());
                        return 0;

                case WM_ACTIVATE:
                        // Activate/deactivate the game and update the Sleep status
                        if (wParam != WA_INACTIVE)
                        {
                                // Get window rectangle and HDC
                                GetClientRect(hWindow, &rect);
                                hDC = GetDC(hWindow);

                                // Do user defined drawing functions
                                m_GamePtr->GameActivate(hDC, rect);

                                // Release HDC
                                ReleaseDC(hWindow, hDC);

                                SetSleep(false);
                        }
                        else
                        {                       
                                // Get window rectangle and HDC
                                GetClientRect(hWindow, &rect);
                                hDC = GetDC(hWindow);

                                // Do user defined drawing functions
                                m_GamePtr->GameDeactivate(hDC, rect);

                                // Release HDC
                                ReleaseDC(hWindow, hDC);
                        }
                        return 0;

                case WM_PAINT:
                        if (m_PaintDoublebuffered)
                        {
                                // Get window, rectangle and HDC
                                hDC = BeginPaint(hWindow, &ps);
                                GetClientRect(hWindow, &rect);

                                // Double buffering code
                                hBufferDC = CreateCompatibleDC(hDC);
                                iWidth = GameEngine::GetSingleton()->GetWidth();
                                iHeight = GameEngine::GetSingleton()->GetHeight();
                                // Create the buffer
                                hBufferBmp = CreateCompatibleBitmap(hDC, iWidth, iHeight);
                                hOldBmp = (HBITMAP) SelectObject(hBufferDC, hBufferBmp);

                                // Do user defined drawing functions on the buffer, parameters added
                                // for ease of drawing
                                m_HdcDraw = hBufferDC;
                                m_RectDraw = rect;

                                m_isPainting = true;
                                m_GamePtr->GamePaint(rect);
                                m_isPainting = false;

                                // As a last step copy the memdc to the hdc
                                BitBlt(hDC, 0, 0, iWidth, iHeight, hBufferDC, 0, 0, SRCCOPY);

                                // Reset the old bmp of the buffer, mainly for show since we kill it anyway
                                SelectObject(hBufferDC, hOldBmp);
                                // Kill the buffer
                                DeleteObject(hBufferBmp);
                                DeleteDC(hBufferDC);

                                // end paint
                                EndPaint(hWindow, &ps);
                        }
                        else
                        {
                                m_HdcDraw = BeginPaint(hWindow, &ps);   
                                GetClientRect(hWindow, &m_RectDraw);

                                m_isPainting = true;
                                m_GamePtr->GamePaint(m_RectDraw);
                                m_isPainting = false;

                                EndPaint(hWindow, &ps);
                        }

                        return 0;

                case WM_CTLCOLOREDIT:
                        return SendMessage((HWND) lParam, WM_CTLCOLOREDIT, wParam, lParam);     // delegate this message to the child window

                case WM_CTLCOLORBTN:
                        return SendMessage((HWND) lParam, WM_CTLCOLOREDIT, wParam, lParam);     // delegate this message to the child window

                case WM_LBUTTONDOWN:
                        m_GamePtr->MouseButtonAction(true, true, LOWORD(lParam), HIWORD(lParam), wParam);
                        return 0;

                case WM_LBUTTONUP:
                        m_GamePtr->MouseButtonAction(true, false, LOWORD(lParam), HIWORD(lParam), wParam);
                        return 0;

                case WM_RBUTTONDOWN:
                        m_GamePtr->MouseButtonAction(false, true, LOWORD(lParam), HIWORD(lParam), wParam);
                        return 0;

                case WM_RBUTTONUP:
                        m_GamePtr->MouseButtonAction(false, false, LOWORD(lParam), HIWORD(lParam), wParam);
                        return 0;

                case WM_MOUSEMOVE:
                        m_GamePtr->MouseMove(LOWORD(lParam), HIWORD(lParam), wParam);
                        return 0;
                        
                case WM_SYSCOMMAND:     // trapping this message prevents a freeze after the ALT key is released
                        if (wParam == SC_KEYMENU) return 0;                     // see win32 API : WM_KEYDOWN
                        else break;    

                case WM_DESTROY:
                        // User defined code for exiting the game
                        m_GamePtr->GameEnd();
                        // Delete the game engine
                        delete GameEngine::GetSingleton();
                        
                        // End the game and exit the application
                        PostQuitMessage(0);
                        return 0;

        }
        return DefWindowProc(hWindow, msg, wParam, lParam);
}

//-----------------------------------------------------------------
// Caller methods
//-----------------------------------------------------------------
bool Caller::AddActionListener(Callable* targetPtr)
{
        return AddListenerObject(targetPtr);
}       

bool Caller::RemoveActionListener(const Callable* targetPtr) 
{
        return RemoveListenerObject(targetPtr);
}

class CallAllActions
{
public:
        CallAllActions(Caller* callerPtr) : m_CallerPtr(callerPtr)
        {}

        void operator()(Callable* callablePtr)
        {
                callablePtr->CallAction(m_CallerPtr);
        }

private:
        Caller* m_CallerPtr;
};

bool Caller::CallListeners()   
{       
        /*
        for (vector<Callable*>::iterator it = m_TargetList.begin(); it != m_TargetList.end(); ++it)
        {
                (*it)->CallAction(this);        
        }
        */
        for_each(m_TargetList.begin(), m_TargetList.end(), CallAllActions(this));

        return (m_TargetList.size() > 0);
}

bool Caller::AddListenerObject(Callable* targetPtr) 
{
        /*
        for (vector<Callable*>::iterator it = m_TargetList.begin(); it != m_TargetList.end(); ++it)
        {
                if ((*it) == target) return false;
        }*/
        vector<Callable*>::iterator pos = find(m_TargetList.begin(), m_TargetList.end(), targetPtr);

        if (pos != m_TargetList.end()) return false;
        
        m_TargetList.push_back(targetPtr);
        return true;
}
        
bool Caller::RemoveListenerObject(const Callable* targetPtr) 
{
        vector<Callable*>::iterator pos = find(m_TargetList.begin(), m_TargetList.end(), targetPtr); // find algorithm from STL

        if (pos == m_TargetList.end()) return false;

        m_TargetList.erase(pos);
        return true;
}

//-----------------------------------------------------------------
// Bitmap methods
//-----------------------------------------------------------------

// set static datamember to zero
int Bitmap::m_nr = 0;

Bitmap::Bitmap(const tstring& nameRef, bool createAlphaChannel): m_Handle(0), m_TransparencyKey(-1), m_Opacity(100), m_PixelsPtr(0), m_Exists(false)
{
        // check if the file to load is a targa
        size_t len = nameRef.length(); 

        if (len > 4 && nameRef.substr(len-4) == _T(".tga")) 
        {
                m_IsTarga = true;
                m_HasAlphaChannel = true;
                TargaLoader* targa = new TargaLoader();

                if (targa->Load((TCHAR*) nameRef.c_str()) == 1)
                {
                        m_Handle = CreateBitmap(targa->GetWidth(), targa->GetHeight(), 1, targa->GetBPP(), (void*)targa->GetImg());
                        if (m_Handle != 0) m_Exists = true;
                }
                
                delete targa;
        }
        // else load as bitmap
        else 
        {
                m_IsTarga = false;
                m_HasAlphaChannel = createAlphaChannel;
                m_Handle = (HBITMAP) LoadImage(GameEngine::GetSingleton()->GetInstance(), nameRef.c_str(), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
                if (m_Handle != 0) m_Exists = true;             
        }

        if (m_IsTarga || createAlphaChannel) LoadBitInfo();
}

Bitmap::Bitmap(int IDBitmap, const tstring& typeRef, bool createAlphaChannel): m_TransparencyKey(-1), m_Opacity(100), m_Exists(false)
{
        if (typeRef == _T("BITMAP"))
        {       
                m_IsTarga = false;
                m_HasAlphaChannel = createAlphaChannel;

                m_Handle = LoadBitmap(GameEngine::GetSingleton()->GetInstance(), MAKEINTRESOURCE(IDBitmap));
                
                if (m_Handle != 0) m_Exists = true;
                
                if (createAlphaChannel) LoadBitInfo();
        }
        else if (typeRef == _T("TGA"))
        {
                m_IsTarga = true;
                m_HasAlphaChannel = true;

                tstringstream buffer;
                buffer << "temp\\targa";
                buffer << m_nr++;
                buffer << ".tga";

                tstring fileName = buffer.str();

                Extract(IDBitmap, _T("TGA"), fileName);

                TargaLoader* targa = new TargaLoader();

                if (targa->Load((TCHAR*) fileName.c_str()) == 1)
                {
                        m_Handle = CreateBitmap(targa->GetWidth(), targa->GetHeight(), 1, targa->GetBPP(), (void*)targa->GetImg());
                        if (m_Handle != 0) m_Exists = true;
                }
                
                delete targa;
                
                LoadBitInfo();
        }
}

void Bitmap::LoadBitInfo()
{
        BITMAPINFOHEADER bminfoheader;
        ::ZeroMemory(&bminfoheader, sizeof(BITMAPINFOHEADER));
        bminfoheader.biSize        = sizeof(BITMAPINFOHEADER);
        bminfoheader.biWidth       = GetWidth();
        bminfoheader.biHeight      = GetHeight();
        bminfoheader.biPlanes      = 1;
        bminfoheader.biBitCount    = 32;
        bminfoheader.biCompression = BI_RGB;
        
        HDC windowDC = GetWindowDC(GameEngine::GetSingleton()->GetWindow());
        m_PixelsPtr = new unsigned char[this->GetWidth() * this->GetHeight() * 4];
        
        GetDIBits(windowDC, m_Handle, 0, GetHeight(), m_PixelsPtr, (BITMAPINFO*) &bminfoheader, DIB_RGB_COLORS); // load pixel info

        // premultiply if it's a targa
        if (m_IsTarga)
        {
                for (int count = 0; count < GetWidth() * GetHeight(); count++)
                {
                        if (m_PixelsPtr[count * 4 + 3] < 255)
                        {
                                m_PixelsPtr[count * 4 + 2] = (unsigned char)((int) m_PixelsPtr[count * 4 + 2] * (int) m_PixelsPtr[count * 4 + 3] / 0xff);
                                m_PixelsPtr[count * 4 + 1] = (unsigned char)((int) m_PixelsPtr[count * 4 + 1] * (int) m_PixelsPtr[count * 4 + 3] / 0xff);
                                m_PixelsPtr[count * 4] = (unsigned char)((int) m_PixelsPtr[count * 4] * (int) m_PixelsPtr[count * 4 + 3] / 0xff);
                        }
                }
                        
                SetDIBits(windowDC, m_Handle, 0, GetHeight(), m_PixelsPtr, (BITMAPINFO*) &bminfoheader, DIB_RGB_COLORS); // save the pixel info for later manipulation
        }       
        // add alpha channel values of 255 for every pixel if bmp
        else
        {               
                for (int count = 0; count < GetWidth() * GetHeight(); count++)
                {
                        m_PixelsPtr[count * 4 + 3] = 255;
                }
        }
        
        SetDIBits(windowDC, m_Handle, 0, GetHeight(), m_PixelsPtr, (BITMAPINFO*) &bminfoheader, DIB_RGB_COLORS); // save the pixel info for later manipulation
}

/*
void Bitmap::Premultiply() // Multiply R, G and B with Alpha
{
    //Note that the APIs use premultiplied alpha, which means that the red,
    //green and blue channel values in the bitmap must be premultiplied with
    //the alpha channel value. For example, if the alpha channel value is x,
    //the red, green and blue channels must be multiplied by x and divided by
    //0xff prior to the call.

    unsigned long Index,nPixels;
    unsigned char *bCur;
    short iPixelSize;

        // Set ptr to start of image
    bCur=pImage;

    // Calc number of pixels
    nPixels=iWidth*iHeight;

        // Get pixel size in bytes
    iPixelSize=iBPP/8;

    for(Index=0;Index!=nPixels;Index++)  // For each pixel
    {

        *bCur=(unsigned char)((int)*bCur* (int)*(bCur+3)/0xff);
        *(bCur+1)=(unsigned char)((int)*(bCur+1)* (int)*(bCur+3)/0xff);
        *(bCur+2)=(unsigned char)((int)*(bCur+2)* (int)*(bCur+3)/0xff);

        bCur+=iPixelSize; // Jump to next pixel
    }
}
*/

Bitmap::~Bitmap()
{
        if (HasAlphaChannel())
        {
                delete[] m_PixelsPtr;
                m_PixelsPtr = 0;
        }

        DeleteObject(m_Handle);
}

bool Bitmap::Exists() const
{
        return m_Exists;
}

void Bitmap::Extract(WORD id, tstring sType, tstring fileName) const
{
        CreateDirectory(_T("temp\\"), NULL);

    HRSRC hrsrc = FindResource(NULL, MAKEINTRESOURCE(id), sType.c_str());
    HGLOBAL hLoaded = LoadResource( NULL, hrsrc);
    LPVOID lpLock =  LockResource(hLoaded);
    DWORD dwSize = SizeofResource(NULL, hrsrc);
    HANDLE hFile = CreateFile(fileName.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD dwByteWritten;
    WriteFile(hFile, lpLock , dwSize , &dwByteWritten , NULL);
    CloseHandle(hFile);
    FreeResource(hLoaded);
} 

HBITMAP Bitmap::GetHandle() const
{
    return m_Handle;
}

int Bitmap::GetWidth() const
{
        if (!Exists()) return 0;

    BITMAP bm;

    GetObject(m_Handle, sizeof(bm), &bm);

    return bm.bmWidth;
}

int Bitmap::GetHeight() const
{
        if (!Exists()) return 0;

        BITMAP bm;

    GetObject(m_Handle, sizeof(bm), &bm);

    return bm.bmHeight;
}

void Bitmap::SetTransparencyColor(COLORREF color) // converts transparency value to pixel-based alpha
{
        m_TransparencyKey = color;

        if (HasAlphaChannel())
        {
                BITMAPINFOHEADER bminfoheader;
                ::ZeroMemory(&bminfoheader, sizeof(BITMAPINFOHEADER));
                bminfoheader.biSize        = sizeof(BITMAPINFOHEADER);
                bminfoheader.biWidth       = GetWidth();
                bminfoheader.biHeight      = GetHeight();
                bminfoheader.biPlanes      = 1;
                bminfoheader.biBitCount    = 32;
                bminfoheader.biCompression = BI_RGB;
                
                HDC windowDC = GetWindowDC(GameEngine::GetSingleton()->GetWindow());

                unsigned char* NewPixels = new unsigned char[this->GetWidth() * this->GetHeight() * 4]; // create 32 bit buffer

                for (int count = 0; count < this->GetWidth() * this->GetHeight(); ++count)
                {
                        if (RGB(m_PixelsPtr[count * 4 + 2], m_PixelsPtr[count * 4 + 1], m_PixelsPtr[count * 4]) == color) // if the color of this pixel == transparency color
                        {
                                ((int*) NewPixels)[count] = 0; // set all four values to zero, this assumes sizeof(int) == 4 on this system
                                                                                                // setting values to zero means premultiplying the RGB values to an alpha of 0
                        }
                        else ((int*) NewPixels)[count] = ((int*) m_PixelsPtr)[count]; // copy all four values from m_PixelsPtr to NewPixels
                }

                SetDIBits(windowDC, m_Handle, 0, GetHeight(), NewPixels, (BITMAPINFO*) &bminfoheader, DIB_RGB_COLORS); // insert pixels into bitmap

                delete[] NewPixels; //destroy buffer

                ReleaseDC(GameEngine::GetSingleton()->GetWindow(), windowDC); // release DC
        }
}

COLORREF Bitmap::GetTransparencyColor() const
{
        return m_TransparencyKey;
}

void Bitmap::SetOpacity(int opacity)
{
        if (HasAlphaChannel())
        {
                if (opacity > 100) m_Opacity = 100;
                else if (opacity < 0) m_Opacity = 0;
                else m_Opacity = opacity;
        }
}

int Bitmap::GetOpacity() const
{
        return m_Opacity;
}

bool Bitmap::IsTarga() const
{
        return m_IsTarga;
}

bool Bitmap::HasAlphaChannel() const
{
        return m_HasAlphaChannel;
}

//-----------------------------------------------------------------
// Audio methods
//-----------------------------------------------------------------

// set static datamember to zero
int Audio::m_nr = 0;

#pragma warning(disable:4311)
#pragma warning(disable:4312)
Audio::Audio(const tstring& nameRef) : m_Playing(false), m_Paused(false), m_MustRepeat(false), m_hWnd(0), m_Volume(100)
{       
        size_t len = nameRef.length();

        ASSERT(len >= 4, _T("Audio name length must be longer than 4 characters!"));
        if (len < 4) return;

        tstring end = nameRef.substr(len - 4);

        if (end == _T(".mp3") || end == _T(".wav") || end == _T(".mid"))
        {
                tstringstream buffer;
                buffer << _T("audio");
                buffer << m_nr++;

                m_Alias = buffer.str();
                m_FileName = nameRef;

                Create(nameRef);
        }
}

Audio::Audio(int IDAudio, const tstring& typeRef) : m_Playing(false), m_Paused(false), m_MustRepeat(false), m_hWnd(0), m_Volume(100)
{
        if (typeRef == _T("MP3") || typeRef == _T("WAV") || typeRef == _T("MID"))
        {
                tstringstream buffer;
                buffer << _T("audio");
                buffer << m_nr++;

                m_Alias = buffer.str();
                m_FileName = tstring(_T("temp\\")) + m_Alias;

                if (typeRef == _T("MP3")) m_FileName += _T(".mp3");
                else if (typeRef == _T("WAV")) m_FileName += _T(".wav");
                else m_FileName += _T(".mid");
                        
                Extract(IDAudio, typeRef, m_FileName);

                Create(m_FileName);
        }
}

void Audio::Create(const tstring& nameRef)
{
        TCHAR response[100];

        tstringstream buffer;

        size_t len = nameRef.length();

        ASSERT(len >= 4, _T("Audio name length must be longer than 4 characters!"));
        if (len < 4) return;

        tstring end = nameRef.substr(len - 4);

        if (end == _T(".mp3")) 
        {
                buffer << _T("open \"") + m_FileName + _T("\" type mpegvideo alias ");
                buffer << m_Alias;
        }
        else if (end == _T(".wav")) 
        {
                buffer << _T("open \"") + m_FileName + _T("\" type waveaudio alias ");
                buffer << m_Alias;
        }
        else if (end == _T(".mid")) 
        {
                buffer << _T("open \"") + m_FileName + _T("\" type sequencer alias ");
                buffer << m_Alias;
        }

        int result = mciSendString(buffer.str().c_str(), 0, 0, 0);      
        if (result != 0) return;
        
        buffer.str(_T(""));
        buffer << _T("set ") + m_Alias + _T(" time format milliseconds");
        mciSendString(buffer.str().c_str(), 0, 0, 0);

        buffer.str(_T(""));
        buffer << _T("status ") + m_Alias + _T(" length");
        mciSendString(buffer.str().c_str(), response, 100, 0);

        buffer.str(_T(""));
        buffer << response;
        buffer >> m_Duration;
        
        // Create a window to catch the MM_MCINOTIFY message with
        m_hWnd = CreateWindow(TEXT("STATIC"), TEXT(""), 0, 0, 0, 0, 0, 0, 0, GameEngine::GetSingleton()->GetInstance(), 0);
        SetWindowLong(m_hWnd, GWL_WNDPROC, (LONG) AudioProcStatic);     // set the custom message loop (subclassing)
        SetWindowLong(m_hWnd, GWL_USERDATA, (LONG) this);                       // set this object as the parameter for the Proc
}

void Audio::Extract(WORD id , const tstring& typeRef, const tstring& fileNameRef) const
{
        CreateDirectory(TEXT("temp\\"), NULL);

    HRSRC hrsrc = FindResource(NULL, MAKEINTRESOURCE(id), typeRef.c_str());
    HGLOBAL hLoaded = LoadResource( NULL, hrsrc);
    LPVOID lpLock =  LockResource(hLoaded);
    DWORD dwSize = SizeofResource(NULL, hrsrc);
    HANDLE hFile = CreateFile(fileNameRef.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD dwByteWritten;
    WriteFile(hFile, lpLock , dwSize , &dwByteWritten , NULL);
    CloseHandle(hFile);
    FreeResource(hLoaded);
} 

#pragma warning(default:4311)
#pragma warning(default:4312)

Audio::~Audio()
{
        Stop();

        tstring sendString = tstring(_T("close")) + m_Alias;
        mciSendString(sendString.c_str(), 0, 0, 0);

        // release the window resources if necessary
        if (m_hWnd)
        {
                DestroyWindow(m_hWnd);
                m_hWnd = 0;
        }
}

void Audio::Play(int msecStart, int msecStop)
{
        if (!m_Playing)
        {
                m_Playing = true;
                m_Paused = false;

                if (msecStop == -1) QueuePlayCommand(msecStart);
                else QueuePlayCommand(msecStart, msecStop);
        }       
        else if (m_Paused)
        {
                m_Paused = false;

                QueueResumeCommand();
        }
}

void Audio::Pause()
{
        if (m_Playing && !m_Paused) 
        {
                m_Paused = true;

                QueuePauseCommand();
        }
}

void Audio::Stop()
{
        if (m_Playing)
        {
                m_Playing = false;
                m_Paused = false;

                QueueStopCommand();
        }
}

void Audio::QueuePlayCommand(int msecStart)
{
        tstringstream buffer;
        buffer << _T("play ") + m_Alias + _T(" from ");
        buffer << msecStart;
        buffer << _T(" notify");
        
        QueueCommand(buffer.str());
}

void Audio::QueuePlayCommand(int msecStart, int msecStop)
{
        tstringstream buffer;
        buffer << _T("play ") + m_Alias + _T(" from ");
        buffer << msecStart;
        buffer << _T(" to ");
        buffer << msecStop;
        buffer << _T(" notify");
        
        QueueCommand(buffer.str());
}

void Audio::QueuePauseCommand()
{
        QueueCommand(_T("pause ") + m_Alias);
}

void Audio::QueueResumeCommand()
{
        QueueCommand(_T("resume ") + m_Alias);
}

void Audio::QueueStopCommand()
{
        QueueCommand(_T("stop ") + m_Alias);
}

void Audio::QueueVolumeCommand(int volume)
{
        tstringstream buffer;
        buffer << _T("setaudio ") + m_Alias + _T(" volume to ");
        buffer << volume * 10;
        
        QueueCommand(buffer.str());
}

void Audio::QueueCommand(const tstring& commandRef)
{
        m_CommandQueue.push(commandRef);
}

void Audio::Tick()
{
        if (!m_CommandQueue.empty())
        {
                SendMCICommand(m_CommandQueue.front());
                m_CommandQueue.pop();
        }
}

void Audio::SendMCICommand(const tstring& commandRef) const
{
        int result = mciSendString(commandRef.c_str(), 0, 0, m_hWnd);
}

const tstring& Audio::GetName() const
{
        return m_FileName;
}
        
const tstring& Audio::GetAlias() const
{
        return m_Alias;
}

bool Audio::IsPlaying() const
{
        return m_Playing;
}

bool Audio::IsPaused() const
{
        return m_Paused;
}

void Audio::SwitchPlayingOff()
{
        m_Playing = false;
        m_Paused = false;
}

void Audio::SetRepeat(bool repeat)
{
        m_MustRepeat = repeat;
}

bool Audio::GetRepeat() const
{
        return m_MustRepeat;
}

int Audio::GetDuration() const
{
        return m_Duration;
}

void Audio::SetVolume(int volume)
{
        m_Volume = min(100, max(0, volume));    // values below 0 and above 100 are trimmed to 0 and 100, respectively

        QueueVolumeCommand(volume);
}

int Audio::GetVolume() const
{
        return m_Volume;
}

bool Audio::Exists() const
{
        return m_hWnd?true:false;
}

int Audio::GetType() const
{
        return Caller::Audio;
}

LRESULT Audio::AudioProcStatic(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{       
        #pragma warning(disable: 4312)
        Audio* audio = reinterpret_cast<Audio*>(GetWindowLong(hWnd, GWL_USERDATA));
        #pragma warning(default: 4312)

        switch (msg)
        {               
        case MM_MCINOTIFY: // message received when an audio file has finished playing - used for repeat function

                if (wParam == MCI_NOTIFY_SUCCESSFUL && audio->IsPlaying()) 
                {
                        audio->SwitchPlayingOff();

                        if (audio->GetRepeat()) audio->Play();  // repeat the audio
                        else audio->CallListeners();                    // notify listeners that the audio file has come to an end
                }
        }
        return 0;       
}

//-----------------------------------------------------------------
// TextBox methods
//-----------------------------------------------------------------

#pragma warning(disable:4311)   
#pragma warning(disable:4312)
TextBox::TextBox(const tstring& textRef) : m_x(0), m_y(0), m_BgColor(RGB(255, 255, 255)), m_ForeColor(RGB(0, 0, 0)), m_BgColorBrush(0), m_Font(0), m_OldFont(0)
{
        // Create the edit box
        m_hWndEdit = CreateWindow(_T("EDIT"), textRef.c_str(), WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_TABSTOP | ES_LEFT | ES_AUTOHSCROLL, 0, 0, 0, 0, GameEngine::GetSingleton()->GetWindow(), NULL, GameEngine::GetSingleton()->GetInstance(), NULL);

        // Set de nieuwe WNDPROC voor de edit box, en houd de oude bij 
        m_procOldEdit = (WNDPROC) SetWindowLong(m_hWndEdit, GWL_WNDPROC, (LONG) EditProcStatic);

        // Stel dit object in als userdata voor de statische wndproc functie van de edit box zodat deze members kan aanroepen
        SetWindowLong(m_hWndEdit, GWL_USERDATA, (LONG) this);
}

TextBox::TextBox() : m_x(0), m_y(0), m_BgColor(RGB(255, 255, 255)), m_ForeColor(RGB(0, 0, 0)), m_BgColorBrush(0), m_Font(0), m_OldFont(0)
{
        // Create the edit box
        m_hWndEdit = CreateWindow(_T("EDIT"), _T(""), WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_TABSTOP | ES_LEFT | ES_AUTOHSCROLL, 0, 0, 0, 0, GameEngine::GetSingleton()->GetWindow(), NULL, GameEngine::GetSingleton()->GetInstance(), NULL);

        // Set de nieuwe WNDPROC voor de edit box, en houd de oude bij 
        m_procOldEdit = (WNDPROC) SetWindowLong(m_hWndEdit, GWL_WNDPROC, (LONG) EditProcStatic);

        // Stel dit object in als userdata voor de statische wndproc functie van de edit box zodat deze members kan aanroepen
        SetWindowLong(m_hWndEdit, GWL_USERDATA, (LONG) this);
}
#pragma warning(default:4311)
#pragma warning(default:4312)

TextBox::~TextBox()
{
        // release the background brush if necessary
        if (m_BgColorBrush != 0) 
        {
                DeleteObject(m_BgColorBrush);
                m_BgColorBrush = 0;
        }

        // release the font if necessary
        if (m_Font != 0)
        {
                SelectObject(GetDC(m_hWndEdit), m_OldFont);
                DeleteObject(m_Font);
                m_Font = m_OldFont = 0;
        }
                
        // release the window resources
        DestroyWindow(m_hWndEdit);
        m_hWndEdit = NULL;
}

void TextBox::SetBounds(int x, int y, int width, int height)
{
        m_x = x;
        m_y = y;

        MoveWindow(m_hWndEdit, x, y, width, height, true);
}

RECT TextBox::GetRect() const
{
        RECT rc;

        GetClientRect(m_hWndEdit, &rc);

        rc.left += m_x;
        rc.right += m_x;
        rc.top += m_y; 
        rc.bottom += m_y;

        return rc;
}

void TextBox::SetEnabled(bool bEnable)
{
        EnableWindow(m_hWndEdit, bEnable);
}

void TextBox::Update() const
{
        UpdateWindow(m_hWndEdit);
}

void TextBox::Show() const
{
        // Show and update the edit box
        ShowWindow(m_hWndEdit, SW_SHOW);
        UpdateWindow(m_hWndEdit);
}

void TextBox::Hide() const
{
        // Show and update the edit box
        ShowWindow(m_hWndEdit, SW_HIDE);
        UpdateWindow(m_hWndEdit);
}

tstring TextBox::GetText() const
{
        int textLength = (int) SendMessage(m_hWndEdit, (UINT) WM_GETTEXTLENGTH, 0, 0);
        
        TCHAR* buffer = new TCHAR[textLength + 1];

        SendMessage(m_hWndEdit, (UINT) WM_GETTEXT, (WPARAM) textLength + 1, (LPARAM) buffer);

        tstring newString(buffer);

        delete buffer;

        return newString;
}

void TextBox::SetText(const tstring& textRef)
{
        SendMessage(m_hWndEdit, WM_SETTEXT, 0, (LPARAM) textRef.c_str());
}

void TextBox::SetFont(const tstring& fontNameRef, bool bold, bool italic, bool underline, int size)
{
        LOGFONT ft;

        //_tcscpy_s(ft.lfFaceName, sizeof(ft.lfFaceName) / sizeof(TCHAR), fontName.c_str());
        for (int teller = 0; teller < (int) fontNameRef.size() && teller < LF_FACESIZE; ++teller)
        {
                ft.lfFaceName[teller] = fontNameRef[teller];
        }

        ft.lfStrikeOut = 0;
        ft.lfUnderline = underline?1:0;
        ft.lfHeight = size;
    ft.lfEscapement = 0;
        ft.lfWeight = bold?FW_BOLD:0;
        ft.lfItalic = italic?1:0;

        // clean up if another custom font was already in place
        if (m_Font != 0) { DeleteObject(m_Font); }

        // create the new font. The WM_CTLCOLOREDIT message will set the font when the textbox is about to redraw
    m_Font = CreateFontIndirect(&ft);

        // redraw the textbox
        InvalidateRect(m_hWndEdit, NULL, true);
}

void TextBox::SetForecolor( COLORREF color )
{
        m_ForeColor = color;
        
        // redraw the textbox
        InvalidateRect(m_hWndEdit, NULL, true);
}

void TextBox::SetBackcolor( COLORREF color )
{
        m_BgColor = color;
        
        if (m_BgColorBrush != 0) DeleteObject(m_BgColorBrush);
        m_BgColorBrush = CreateSolidBrush( color );
        
        // redraw the textbox
        InvalidateRect(m_hWndEdit, NULL, true);
}

COLORREF TextBox::GetForecolor() const
{
        return m_ForeColor;
}

COLORREF TextBox::GetBackcolor() const
{
        return m_BgColor;
}

HBRUSH TextBox::GetBackcolorBrush() const
{
        return m_BgColorBrush;
}

LRESULT TextBox::EditProcStatic(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        #pragma warning(disable: 4312)
        return reinterpret_cast<TextBox*>(GetWindowLong(hWnd, GWL_USERDATA))->EditProc(hWnd, msg, wParam, lParam);
        #pragma warning(default: 4312)
}

LRESULT TextBox::EditProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch (msg)
        {               
        case WM_CTLCOLOREDIT:
                SetBkColor((HDC) wParam, GetBackcolor() );
                SetTextColor((HDC) wParam, GetForecolor() );
                if (m_Font != 0) 
                {
                        if (m_OldFont == 0) m_OldFont = (HFONT) SelectObject((HDC) wParam, m_Font);
                        else SelectObject((HDC) wParam, m_Font);
                }
                return (LRESULT) GetBackcolorBrush();

        case WM_CHAR: 
                if (wParam == VK_TAB) return 0;
                if (wParam == VK_RETURN) return 0;
                break;

        case WM_KEYDOWN :
                switch (wParam)
                {
                case VK_TAB:
                        if (GameEngine::GetSingleton()->IsKeyDown(VK_SHIFT)) GameEngine::GetSingleton()->TabPrevious(hWnd);
                        else GameEngine::GetSingleton()->TabNext(hWnd);
                        return 0;
                case VK_ESCAPE:
                        SetFocus(GetParent(hWnd));
                        return 0;
                case VK_RETURN:
                        //if (m_Target) result = m_Target->CallAction(this);
                        CallListeners();
                        break;
                }
        }
        return CallWindowProc(m_procOldEdit, hWnd, msg, wParam, lParam);
}



//-----------------------------------------------------------------
// Button methods
//-----------------------------------------------------------------

#pragma warning(disable:4311)
#pragma warning(disable:4312)
Button::Button(const tstring& textRef) : m_x(0), m_y(0), m_Armed(false), m_Font(0), m_OldFont(0)
{
        // Create the button object
        m_hWndButton = CreateWindow(_T("BUTTON"), textRef.c_str(), WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_TABSTOP | BS_PUSHBUTTON, 0, 0, 0, 0, GameEngine::GetSingleton()->GetWindow(), NULL, GameEngine::GetSingleton()->GetInstance(), NULL);

        // Set de new WNDPROC for the button, and store the old one
        m_procOldButton = (WNDPROC) SetWindowLong(m_hWndButton, GWL_WNDPROC, (LONG) ButtonProcStatic);

        // Store 'this' as data for the Button object so that the static PROC can call the member proc
        SetWindowLong(m_hWndButton, GWL_USERDATA, (LONG) this);
}

Button::Button() : m_x(0), m_y(0), m_Armed(false), m_Font(0), m_OldFont(0)
{
        // Create the button object
        m_hWndButton = CreateWindow(_T("BUTTON"), _T(""), WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_TABSTOP | BS_PUSHBUTTON, 0, 0, 0, 0, GameEngine::GetSingleton()->GetWindow(), NULL, GameEngine::GetSingleton()->GetInstance(), NULL);

        // Set de new WNDPROC for the button, and store the old one
        m_procOldButton = (WNDPROC) SetWindowLong(m_hWndButton, GWL_WNDPROC, (LONG) ButtonProcStatic);

        // Store 'this' as data for the Button object so that the static PROC can call the member proc
        SetWindowLong(m_hWndButton, GWL_USERDATA, (LONG) this);
}
#pragma warning(default:4311)
#pragma warning(default:4312)

Button::~Button()
{
        // release the font if necessary
        if (m_Font != 0)
        {
                SelectObject(GetDC(m_hWndButton), m_OldFont);
                DeleteObject(m_Font);
                m_Font = m_OldFont = 0;
        }
                
        // release the window resource
        DestroyWindow(m_hWndButton);
        m_hWndButton = NULL;    
}

void Button::SetBounds(int x, int y, int width, int height)
{
        m_x = x;
        m_y = y;

        MoveWindow(m_hWndButton, x, y, width, height, true);
}

RECT Button::GetRect() const
{
        RECT rc;

        GetClientRect(m_hWndButton, &rc);
        
        rc.left += m_x;
        rc.right += m_x;
        rc.top += m_y; 
        rc.bottom += m_y;

        return rc;
}

void Button::SetEnabled(bool bEnable)
{
        EnableWindow(m_hWndButton, bEnable);
}

void Button::Update() const
{
        UpdateWindow(m_hWndButton);
}

void Button::Show() const
{
        // Show and update the button
        ShowWindow(m_hWndButton, SW_SHOW);
        UpdateWindow(m_hWndButton);
}

void Button::Hide() const
{
        // Show and update the button
        ShowWindow(m_hWndButton, SW_HIDE);
        UpdateWindow(m_hWndButton);
}

tstring Button::GetText() const
{
        int textLength = (int) SendMessage(m_hWndButton, (UINT) WM_GETTEXTLENGTH, 0, 0);
        
        TCHAR* buffer = new TCHAR[textLength + 1];

        SendMessage(m_hWndButton, (UINT) WM_GETTEXT, (WPARAM) textLength + 1, (LPARAM) buffer);

        tstring newString(buffer);

        delete buffer;

        return newString;
}

void Button::SetText(const tstring& textRef)
{
        SendMessage(m_hWndButton, WM_SETTEXT, 0, (LPARAM) textRef.c_str());
}

void Button::SetFont(const tstring& fontNameRef, bool bold, bool italic, bool underline, int size)
{
        LOGFONT ft;

        //_tcscpy_s(ft.lfFaceName, sizeof(ft.lfFaceName) / sizeof(TCHAR), fontName.c_str());
        for (int teller = 0; teller < (int) fontNameRef.size() && teller < LF_FACESIZE; ++teller)
        {
                ft.lfFaceName[teller] = fontNameRef[teller];
        }

        ft.lfStrikeOut = 0;
        ft.lfUnderline = underline?1:0;
        ft.lfHeight = size;
    ft.lfEscapement = 0;
        ft.lfWeight = bold?FW_BOLD:0;
        ft.lfItalic = italic?1:0;

        // clean up if another custom font was already in place
        if (m_Font != 0) { DeleteObject(m_Font); }

        // create the new font. The WM_CTLCOLOREDIT message will set the font when the button is about to redraw
    m_Font = CreateFontIndirect(&ft);

        // redraw the button
        InvalidateRect(m_hWndButton, NULL, true);
}

LRESULT Button::ButtonProcStatic(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        #pragma warning(disable: 4312)
        return reinterpret_cast<Button*>(GetWindowLong(hWnd, GWL_USERDATA))->ButtonProc(hWnd, msg, wParam, lParam);
        #pragma warning(default: 4312)
}

LRESULT Button::ButtonProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch (msg)
        {
        case WM_CTLCOLOREDIT:
                if (m_Font != 0) 
                {
                        if (m_OldFont == 0) m_OldFont = (HFONT) SelectObject((HDC) wParam, m_Font);
                        else SelectObject((HDC) wParam, m_Font);
                }
                return 0;

        case WM_CHAR: 
                if (wParam == VK_TAB) return 0;
                if (wParam == VK_RETURN) return 0;
                break;

        case WM_KEYDOWN :
                switch (wParam)
                {
                case VK_TAB:                    
                        if (GameEngine::GetSingleton()->IsKeyDown(VK_SHIFT)) GameEngine::GetSingleton()->TabPrevious(hWnd);
                        else GameEngine::GetSingleton()->TabNext(hWnd);
                        return 0;
                case VK_ESCAPE:
                        SetFocus(GetParent(hWnd));
                        return 0;
                case VK_SPACE:
                        //if (m_Target) result = m_Target->CallAction(this);
                        CallListeners();
                        break;
                }
                break;
        case WM_LBUTTONDOWN :
        case WM_LBUTTONDBLCLK:                                  // clicking fast will throw LBUTTONDBLCLK's as well as LBUTTONDOWN's, you need to capture both to catch all button clicks
                m_Armed = true;
                break;
        case WM_LBUTTONUP :
                if (m_Armed)
                {
                        RECT rc;
                        POINT pt;
                        GetWindowRect(hWnd, &rc);
                        GetCursorPos(&pt);

                        //if (PtInRect(&rc, pt) && m_Target) result = m_Target->CallAction(this);
                        if (PtInRect(&rc, pt)) CallListeners();

                        m_Armed = false;
                }
        }
        return CallWindowProc(m_procOldButton, hWnd, msg, wParam, lParam);
}

//-----------------------------------------------------------------
// Timer methods
//-----------------------------------------------------------------

Timer::Timer(int msec, Callable* targetPtr) : m_IsRunning(false)
{
        m_Delay = msec;

        AddActionListener(targetPtr);
}

Timer::~Timer()
{
        if (m_IsRunning) Stop(); // stop closes the handle

        // no objects to delete
}

void Timer::Start()
{
        if (m_IsRunning == false)
        {
                CreateTimerQueueTimer(&m_TimerHandle, NULL, TimerProcStatic, (void*) this, m_Delay, m_Delay, WT_EXECUTEINTIMERTHREAD);  
                m_IsRunning = true;
        }
}

void Timer::Stop()
{       
        if (m_IsRunning == true)
        {
                DeleteTimerQueueTimer(NULL, m_TimerHandle, NULL);  
                //CloseHandle (m_TimerHandle);          DeleteTimerQueueTimer automatically closes the handle? MSDN Documentation seems to suggest this
                
                m_IsRunning = false;
        }
}

bool Timer::IsRunning() const
{
        return m_IsRunning;
}

void Timer::SetDelay(int msec)
{
        m_Delay = max(msec, 1); // timer will not accept values less than 1 msec

        if (m_IsRunning)
        {
                Stop();
                Start();
        }
}

int Timer::GetDelay() const
{
        return m_Delay;
}

void CALLBACK Timer::TimerProcStatic(void* lpParameter, BOOLEAN TimerOrWaitFired)
{
        Timer* timer = reinterpret_cast<Timer*>(lpParameter);

        //if (timer->m_IsRunning) timer->m_Target->CallAction(timer);
        if (timer->m_IsRunning) timer->CallListeners();
}

//-----------------------------------------------------------------
// Targa loader code
//-----------------------------------------------------------------
 
#define IMG_OK              0x1
#define IMG_ERR_NO_FILE     0x2
#define IMG_ERR_MEM_FAIL    0x4
#define IMG_ERR_BAD_FORMAT  0x8
#define IMG_ERR_UNSUPPORTED 0x40
 
TargaLoader::TargaLoader()
{ 
        pImage=pPalette=pData=NULL;
        iWidth=iHeight=iBPP=bEnc=0;
        lImageSize=0;
}
 
TargaLoader::~TargaLoader()
{
        if(pImage)
        {
                delete [] pImage;
                pImage=NULL;
        }
 
        if(pPalette)
        {
                delete [] pPalette;
                pPalette=NULL;
        }
 
        if(pData)
        {
                delete [] pData;
                pData=NULL;
        }
}
 
int TargaLoader::Load(const TCHAR* fileNamePtr)
{
        using namespace std;
        ifstream fIn;
        unsigned long ulSize;
        int iRet;
 
        // Clear out any existing image and palette
        if(pImage)
    {
                delete [] pImage;
                pImage=NULL;
    }
 
        if(pPalette)
    {
                delete [] pPalette;
                pPalette=NULL;
    }
 
        // Open the specified file
        //fIn.open(szFilename,ios::binary);
        fIn.open(fileNamePtr,ios::binary);
    
        if(fIn==NULL) return IMG_ERR_NO_FILE;
 
        // Get file size
        fIn.seekg(0,ios_base::end);
        ulSize=fIn.tellg();
        fIn.seekg(0,ios_base::beg);
 
        // Allocate some space
        // Check and clear pDat, just in case
        if(pData) delete [] pData; 
 
        pData=new unsigned char[ulSize];
 
        if(pData==NULL)
    {
                fIn.close();
                return IMG_ERR_MEM_FAIL;
        }
 
        // Read the file into memory
        fIn.read((char*)pData,ulSize);
 
        fIn.close();
 
        // Process the header
        iRet=ReadHeader();
 
        if(iRet!=IMG_OK) return iRet;
 
        switch(bEnc)
        {
    case 1: // Raw Indexed
                // Check filesize against header values
        if((lImageSize+18+pData[0]+768)>ulSize) return IMG_ERR_BAD_FORMAT;
 
                // Double check image type field
                if(pData[1]!=1) return IMG_ERR_BAD_FORMAT;
 
                // Load image data
                iRet=LoadRawData();
        
                if(iRet!=IMG_OK) return iRet;
 
                // Load palette
        iRet=LoadTgaPalette();
        
                if(iRet!=IMG_OK) return iRet;
 
       break;
 
    case 2: // Raw RGB
                // Check filesize against header values
                if((lImageSize+18+pData[0])>ulSize) return IMG_ERR_BAD_FORMAT;
 
                // Double check image type field
        if(pData[1]!=0) return IMG_ERR_BAD_FORMAT;
 
                // Load image data
                iRet=LoadRawData();
        
                if(iRet!=IMG_OK) return iRet;
 
                //BGRtoRGB(); // Convert to RGB
                break;
 
    case 9: // RLE Indexed
        // Double check image type field
        if(pData[1]!=1) return IMG_ERR_BAD_FORMAT;
 
                // Load image data
                iRet=LoadTgaRLEData();
                        
                if(iRet!=IMG_OK) return iRet;
 
                // Load palette
                iRet=LoadTgaPalette();
        
                if(iRet!=IMG_OK) return iRet;
 
                break;
        
        case 10: // RLE RGB
       // Double check image type field
       if(pData[1]!=0) return IMG_ERR_BAD_FORMAT;
 
       // Load image data
       iRet=LoadTgaRLEData();
        
           if(iRet!=IMG_OK) return iRet;
 
       //BGRtoRGB(); // Convert to RGB
       break;
 
        default:
                return IMG_ERR_UNSUPPORTED;
    }
 
        // Check flip bit
        if((pData[17] & 0x20)==0) FlipImg();
 
        // Release file memory
        delete [] pData;
        pData=NULL;

        return IMG_OK;
}
 
int TargaLoader::ReadHeader() // Examine the header and populate our class attributes
{
        short ColMapStart,ColMapLen;
        short x1,y1,x2,y2;
 
        if(pData==NULL)
                return IMG_ERR_NO_FILE;
 
        if(pData[1]>1)    // 0 (RGB) and 1 (Indexed) are the only types we know about
                return IMG_ERR_UNSUPPORTED;
 
        bEnc=pData[2];     // Encoding flag  1 = Raw indexed image
                      //                2 = Raw RGB
                      //                3 = Raw greyscale
                      //                9 = RLE indexed
                      //               10 = RLE RGB
                      //               11 = RLE greyscale
                      //               32 & 33 Other compression, indexed
 
        if(bEnc>11)       // We don't want 32 or 33
                return IMG_ERR_UNSUPPORTED;
 
 
        // Get palette info
        memcpy(&ColMapStart,&pData[3],2);
        memcpy(&ColMapLen,&pData[5],2);
 
        // Reject indexed images if not a VGA palette (256 entries with 24 bits per entry)
        if(pData[1]==1) // Indexed
    {
                if(ColMapStart!=0 || ColMapLen!=256 || pData[7]!=24) return IMG_ERR_UNSUPPORTED;
    }
 
        // Get image window and produce width & height values
        memcpy(&x1,&pData[8],2);
        memcpy(&y1,&pData[10],2);
        memcpy(&x2,&pData[12],2);
        memcpy(&y2,&pData[14],2);
 
        iWidth=(x2-x1);
        iHeight=(y2-y1);
 
        if(iWidth<1 || iHeight<1) return IMG_ERR_BAD_FORMAT;
 
        // Bits per Pixel
        iBPP=pData[16];
 
        // Check flip / interleave byte
        if(pData[17]>32) // Interleaved data
                return IMG_ERR_UNSUPPORTED;
 
        // Calculate image size
        lImageSize=(iWidth * iHeight * (iBPP/8));
 
        return IMG_OK;
}
 
int TargaLoader::LoadRawData() // Load uncompressed image data
{
        short iOffset;
 
        if(pImage) // Clear old data if present
                delete [] pImage;
 
        pImage=new unsigned char[lImageSize];
 
        if(pImage==NULL) return IMG_ERR_MEM_FAIL;
 
        iOffset=pData[0]+18; // Add header to ident field size
 
        if(pData[1]==1) // Indexed images
                iOffset+=768;  // Add palette offset
 
        memcpy(pImage,&pData[iOffset],lImageSize);
 
        return IMG_OK;
}
 
int TargaLoader::LoadTgaRLEData() // Load RLE compressed image data
{
        short iOffset,iPixelSize;
        unsigned char *pCur;
        unsigned long Index=0;
        unsigned char bLength,bLoop;
 
        // Calculate offset to image data
        iOffset=pData[0]+18;
 
        // Add palette offset for indexed images
        if(pData[1]==1) iOffset+=768; 
 
        // Get pixel size in bytes
        iPixelSize=iBPP/8;
 
        // Set our pointer to the beginning of the image data
        pCur=&pData[iOffset];
 
        // Allocate space for the image data
        if(pImage!=NULL) delete [] pImage;
 
        pImage=new unsigned char[lImageSize];
 
        if(pImage==NULL) return IMG_ERR_MEM_FAIL;
 
        // Decode
        while(Index<lImageSize) 
    {
                if(*pCur & 0x80) // Run length chunk (High bit = 1)
                {
                        bLength=*pCur-127; // Get run length
                        pCur++;            // Move to pixel data  
 
                        // Repeat the next pixel bLength times
                        for(bLoop=0;bLoop!=bLength;++bLoop,Index+=iPixelSize)
                        memcpy(&pImage[Index],pCur,iPixelSize);
  
                        pCur+=iPixelSize; // Move to the next descriptor chunk
                }
                else // Raw chunk
                {
                        bLength=*pCur+1; // Get run length
                        pCur++;          // Move to pixel data
 
                        // Write the next bLength pixels directly
                        for(bLoop=0;bLoop!=bLength;++bLoop,Index+=iPixelSize,pCur+=iPixelSize)
                        memcpy(&pImage[Index],pCur,iPixelSize);
                }
    }
 
        return IMG_OK;
}
 
int TargaLoader::LoadTgaPalette() // Load a 256 color palette
{
        unsigned char bTemp;
        short iIndex,iPalPtr;
  
        // Delete old palette if present
        if(pPalette)
    {
                delete [] pPalette;
                pPalette=NULL;
    }
 
        // Create space for new palette
        pPalette=new unsigned char[768];
 
        if(pPalette==NULL) return IMG_ERR_MEM_FAIL;
 
        // VGA palette is the 768 bytes following the header
        memcpy(pPalette,&pData[pData[0]+18],768);
 
        // Palette entries are BGR ordered so we have to convert to RGB
        for(iIndex=0,iPalPtr=0;iIndex!=256;++iIndex,iPalPtr+=3)
    {
                bTemp=pPalette[iPalPtr];               // Get Blue value
                pPalette[iPalPtr]=pPalette[iPalPtr+2]; // Copy Red to Blue
                pPalette[iPalPtr+2]=bTemp;             // Replace Blue at the end
        }
 
        return IMG_OK;
} 
 
void TargaLoader::BGRtoRGB() // Convert BGR to RGB (or back again)
{
        unsigned long Index,nPixels;
        unsigned char *bCur;
        unsigned char bTemp;
        short iPixelSize;
 
        // Set ptr to start of image
        bCur=pImage;
 
        // Calc number of pixels
        nPixels=iWidth*iHeight;
 
        // Get pixel size in bytes
        iPixelSize=iBPP/8;
 
        for(Index=0;Index!=nPixels;Index++)  // For each pixel
    {
                bTemp=*bCur;      // Get Blue value
                *bCur=*(bCur+2);  // Swap red value into first position
                *(bCur+2)=bTemp;  // Write back blue to last position
 
                bCur+=iPixelSize; // Jump to next pixel
    }
}
 
void TargaLoader::FlipImg() // Flips the image vertically (Why store images upside down?)
{
        unsigned char bTemp;
        unsigned char *pLine1, *pLine2;
        int iLineLen,iIndex;
 
        iLineLen=iWidth*(iBPP/8);
        pLine1=pImage;
        pLine2=&pImage[iLineLen * (iHeight - 1)];
 
        for( ;pLine1<pLine2;pLine2-=(iLineLen*2))
    {
                for(iIndex=0;iIndex!=iLineLen;pLine1++,pLine2++,iIndex++)
                {
                        bTemp=*pLine1;
                        *pLine1=*pLine2;
                        *pLine2=bTemp;       
                }
        }  
}
  
int TargaLoader::GetBPP() const 
{
        return iBPP;
}
 
int TargaLoader::GetWidth() const
{
        return iWidth;
}
 
int TargaLoader::GetHeight() const
{
        return iHeight;
}
 
const unsigned char* TargaLoader::GetImg() const
{
        return pImage;
}
 
const unsigned char* TargaLoader::GetPalette() const
{
        return pPalette;
}

//-----------------------------------------------------------------
// OutputDebugString functions
//-----------------------------------------------------------------

void OutputDebugString(const tstring& textRef)
{
        OutputDebugString(textRef.c_str());
}


//---------------------------
// HitRegion methods
//---------------------------
HitRegion::HitRegion() : m_HitRegion(0)
{
        // nothing to create
}

HitRegion::~HitRegion()
{
        if (m_HitRegion)
                DeleteObject(m_HitRegion);
}


bool HitRegion::Create(int type, int x, int y, int width, int height)
{
        if (m_HitRegion) DeleteObject(m_HitRegion);

        if (type == HitRegion::Ellipse)
                m_HitRegion = CreateEllipticRgn(x, y, x + width, y + height);
        else
                m_HitRegion = CreateRectRgn(x, y, x + width, y + height);

        return true;
}

bool HitRegion::Create(int type, const POINT* pointsArr, int numberOfPoints)
{
        if (m_HitRegion) DeleteObject(m_HitRegion);

        m_HitRegion = CreatePolygonRgn(pointsArr, numberOfPoints, WINDING);

        return true;
}       

bool HitRegion::Create(int type, const Bitmap* bmpPtr, COLORREF cTransparent, COLORREF cTolerance)
{
        if (!bmpPtr->Exists()) return false;

        HBITMAP hBitmap = bmpPtr->GetHandle();

        if (!hBitmap) return false;

        if (m_HitRegion) DeleteObject(m_HitRegion);

        // for some reason, the BitmapToRegion function has R and B switched. Flipping the colors to get the right result.
        COLORREF flippedTransparent = RGB(GetBValue(cTransparent), GetGValue(cTransparent), GetRValue(cTransparent));
        COLORREF flippedTolerance = RGB(GetBValue(cTolerance), GetGValue(cTolerance), GetRValue(cTolerance));

        m_HitRegion = BitmapToRegion(hBitmap, flippedTransparent, flippedTolerance);

        return (m_HitRegion?true:false);
}       

//      BitmapToRegion :        Create a region from the "non-transparent" pixels of a bitmap
//      Author :                Jean-Edouard Lachand-Robert (http://www.geocities.com/Paris/LeftBank/1160/resume.htm), June 1998
//  Some modifications: Kevin Hoefman, Febr 2007
HRGN HitRegion::BitmapToRegion(HBITMAP hBmp, COLORREF cTransparentColor, COLORREF cTolerance) const
{
        HRGN hRgn = NULL;

        if (hBmp)
        {
                // Create a memory DC inside which we will scan the bitmap content
                HDC hMemDC = CreateCompatibleDC(NULL);

                if (hMemDC)
                {
                        // Get bitmap siz
                        BITMAP bm;
                        GetObject(hBmp, sizeof(bm), &bm);

                        // Create a 32 bits depth bitmap and select it into the memory DC
                        BITMAPINFOHEADER RGB32BITSBITMAPINFO = {
                                        sizeof(BITMAPINFOHEADER),       // biSize
                                        bm.bmWidth,                                     // biWidth;
                                        bm.bmHeight,                            // biHeight;
                                        1,                                                      // biPlanes;
                                        32,                                                     // biBitCount
                                        BI_RGB,                                         // biCompression;
                                        0,                                                      // biSizeImage;
                                        0,                                                      // biXPelsPerMeter;
                                        0,                                                      // biYPelsPerMeter;
                                        0,                                                      // biClrUsed;
                                        0                                                       // biClrImportant;
                        };
                        VOID * pbits32;
                        HBITMAP hbm32 = CreateDIBSection(hMemDC, (BITMAPINFO *)&RGB32BITSBITMAPINFO, DIB_RGB_COLORS, &pbits32, NULL, 0);

                        if (hbm32)
                        {
                                HBITMAP holdBmp = (HBITMAP)SelectObject(hMemDC, hbm32);

                                // Create a DC just to copy the bitmap into the memory D
                                HDC hDC = CreateCompatibleDC(hMemDC);

                                if (hDC)
                                {
                                        // Get how many bytes per row we have for the bitmap bits (rounded up to 32 bits
                                        BITMAP bm32;
                                        GetObject(hbm32, sizeof(bm32), &bm32);
                                        while (bm32.bmWidthBytes % 4)
                                                bm32.bmWidthBytes++;

                                        // Copy the bitmap into the memory D
                                        HBITMAP holdBmp = (HBITMAP)SelectObject(hDC, hBmp);
                                        BitBlt(hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY);

                                        // For better performances, we will use the ExtCreateRegion() function to create the
                                        // region. This function take a RGNDATA structure on entry. We will add rectangles b
                                        // amount of ALLOC_UNIT number in this structure
                                        #define ALLOC_UNIT      100
                                        DWORD maxRects = ALLOC_UNIT;
                                        HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects));
                                        RGNDATA *pData = (RGNDATA *)GlobalLock(hData);
                                        pData->rdh.dwSize = sizeof(RGNDATAHEADER);
                                        pData->rdh.iType = RDH_RECTANGLES;
                                        pData->rdh.nCount = pData->rdh.nRgnSize = 0;
                                        SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);

                                        // Keep on hand highest and lowest values for the "transparent" pixel
                                        BYTE lr = GetRValue(cTransparentColor);
                                        BYTE lg = GetGValue(cTransparentColor);
                                        BYTE lb = GetBValue(cTransparentColor);
                                        BYTE hr = min(0xff, lr + GetRValue(cTolerance));
                                        BYTE hg = min(0xff, lg + GetGValue(cTolerance));
                                        BYTE hb = min(0xff, lb + GetBValue(cTolerance));

                                        // Scan each bitmap row from bottom to top (the bitmap is inverted vertically
                                        BYTE *p32 = (BYTE *)bm32.bmBits + (bm32.bmHeight - 1) * bm32.bmWidthBytes;
                                        for (int y = 0; y < bm.bmHeight; y++)
                                        {
                                                // Scan each bitmap pixel from left to righ
                                                for (int x = 0; x < bm.bmWidth; x++)
                                                {
                                                        // Search for a continuous range of "non transparent pixels"
                                                        int x0 = x;
                                                        LONG *p = (LONG *)p32 + x;
                                                        while (x < bm.bmWidth)
                                                        {
                                                                BYTE b = GetRValue(*p);
                                                                if (b >= lr && b <= hr)
                                                                {
                                                                        b = GetGValue(*p);
                                                                        if (b >= lg && b <= hg)
                                                                        {
                                                                                b = GetBValue(*p);
                                                                                if (b >= lb && b <= hb)
                                                                                        // This pixel is "transparent"
                                                                                        break;
                                                                        }
                                                                }
                                                                p++;
                                                                x++;
                                                        }

                                                        if (x > x0)
                                                        {
                                                                // Add the pixels (x0, y) to (x, y+1) as a new rectangle in the regio
                                                                if (pData->rdh.nCount >= maxRects)
                                                                {
                                                                        GlobalUnlock(hData);
                                                                        maxRects += ALLOC_UNIT;
                                                                        hData = GlobalReAlloc(hData, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), GMEM_MOVEABLE);
                                                                        pData = (RGNDATA *)GlobalLock(hData);
                                                                
                                                                }
                                                                RECT *pr = (RECT *)&pData->Buffer;
                                                                SetRect(&pr[pData->rdh.nCount], x0, y, x, y+1);
                                                                if (x0 < pData->rdh.rcBound.left)
                                                                        pData->rdh.rcBound.left = x0;
                                                                if (y < pData->rdh.rcBound.top)
                                                                        pData->rdh.rcBound.top = y;
                                                                if (x > pData->rdh.rcBound.right)
                                                                        pData->rdh.rcBound.right = x;
                                                                if (y+1 > pData->rdh.rcBound.bottom)
                                                                        pData->rdh.rcBound.bottom = y+1;
                                                                pData->rdh.nCount++;

                                                                /*
                                                                // On Windows98, ExtCreateRegion() may fail if the number of rectangles is to
                                                                // large (ie: > 4000). Therefore, we have to create the region by multiple steps
                                                                if (pData->rdh.nCount == 2000)
                                                                {
                                                                        HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
                                                                        
                                                                        // Free the data
                                                                        GlobalFree(hData);

                                                                        if (hRgn)
                                                                        {
                                                                                CombineRgn(hRgn, hRgn, h, RGN_OR);
                                                                                DeleteObject(h);
                                                                        }
                                                                        else
                                                                                hRgn = h;
                                                                        pData->rdh.nCount = 0;
                                                                        SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
                                                                }
                                                                */
                                                        }
                                                }

                                                // Go to next row (remember, the bitmap is inverted vertically
                                                p32 -= bm32.bmWidthBytes;
                                        }

                                        // Create or extend the region with the remaining rectangle
                                        HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);

                                        if (hRgn)
                                        {
                                                CombineRgn(hRgn, hRgn, h, RGN_OR);
                                                DeleteObject(h);
                                        }
                                        else
                                                hRgn = h;

                                        // Clean u
                                        SelectObject(hDC, holdBmp);
                                        DeleteDC(hDC);
                                }

                                DeleteObject(SelectObject(hMemDC, holdBmp));
                        }

                        DeleteDC(hMemDC);
                }
        }

        return hRgn;
}
        
HitRegion* HitRegion::Clone() const
{
        HitRegion* temp = new HitRegion();

        temp->m_HitRegion = CreateRectRgn(0, 0, 10, 10); // create dummy region
        CombineRgn(temp->m_HitRegion, m_HitRegion, 0, RGN_COPY);

        return temp;
}
        
void HitRegion::Move(int x, int y)
{
        OffsetRgn(m_HitRegion, x, y);
}
        
RECT HitRegion::GetDimension() const
{
        RECT boundingbox;
        GetRgnBox(m_HitRegion, &boundingbox);

        return boundingbox;
}

HRGN HitRegion::GetHandle() const
{
        return m_HitRegion;
}

bool HitRegion::HitTest(HitRegion* regPtr) const
{
        HRGN temp = CreateRectRgn(0, 0, 10, 10);                        // dummy region
        bool result = (CombineRgn(temp, m_HitRegion, regPtr->m_HitRegion, RGN_AND) != NULLREGION);

        DeleteObject(temp);
        return result;
}
        
bool HitRegion::HitTest(int x, int y) const
{
        return PtInRegion(m_HitRegion, x, y)?true:false;
}
        
POINT HitRegion::CollisionTest(HitRegion* regPtr) const
{
        POINT result;

        HRGN temp = CreateRectRgn(0, 0, 10, 10);                        // dummy region
        int overlap = CombineRgn(temp, m_HitRegion, regPtr->m_HitRegion, RGN_AND);

        if (overlap == NULLREGION)
        {
                result.x = -1000000;
                result.y = -1000000;
        }
        else
        {
                RECT boundingbox;
                GetRgnBox(temp, &boundingbox);
                result.x = boundingbox.left + (boundingbox.right - boundingbox.left)/2;
                result.y = boundingbox.top + (boundingbox.bottom - boundingbox.top)/2;
        }

        DeleteObject(temp);
        
        return result;
}