Window.cpp

#include "Window.hpp"
#include "Line2D.hpp"
#include "Point2D.hpp"
#include "Vector2D.hpp"
#include "resource.h"
#include "Shapes/Box2D.hpp"
#include "Shapes/Circle.hpp"
#include "Shapes/Ellipse.hpp"
#include <commctrl.h> // Required for TBBUTTON and toolbar functions

// Functions defined in Main.cpp
extern void AddLine2D(CGF::Line2D & line);
extern void AddBox2D(CGF::Box2D & box);
extern void AddCircle(CGF::Circle & circle);
extern void AddEllipse(CGF::Ellipse & ellipse);
extern void SetPreviousPoint(unsigned int x, unsigned int y);
extern void ClearLine2D();
extern void ClearBox2D();
extern void ClearCircle();
extern void ClearEllipse();
extern void ClearPreviousPoint();

namespace CGF
{
    
////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Window default constructor
*/
////////////////////////////////////////////////////////////////////////////////
Window::Window() : mWidth(0), mHeight(0), mRunning(false), 
                    mHwnd(0), mHdc(0), mWindowInstance(0), mClassName("WndClass"), 
                    mBitmap(0), mOldBitmap(0), mBitmapDC(0), mSurface(0)
{}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Window destructor
*/
////////////////////////////////////////////////////////////////////////////////
Window::~Window()
{
    // Get rid of the secondary window
    mBitmap = (HBITMAP)::SelectObject(mBitmapDC, mOldBitmap);
    ::DeleteObject(mBitmap);
    ::ReleaseDC(NULL, mBitmapDC);

    // Destroy the toolbar
    ::DestroyWindow(mHtoolbar); 

    // Get rid of the main window
    UnregisterWndClass();
    ::ReleaseDC(mHwnd, mHdc);

    // Destroy the main window
    ::DestroyWindow(mHwnd);
    mHwnd = 0;
    gHwnd = 0;  // Get rid of the global window handle reference
    
    mHdc = 0;
    mRunning = false;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Returns the width of the Window
    @return	Width of the Window
*/
////////////////////////////////////////////////////////////////////////////////
unsigned int Window::Width() const
{
    return mWidth;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Returns the height of the Window
    @return	Height of the Window
*/
////////////////////////////////////////////////////////////////////////////////
unsigned int Window::Height() const
{
    return mHeight;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Returns the status of the Window (running or not running)
    @return	true if the Window is runing, false if not
*/
////////////////////////////////////////////////////////////////////////////////
bool Window::Running() const
{
    return mRunning;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Registers the WNDCLASS with Windows
    @param	hInstance
            Windows window instance
    @return	true for success, false for error
*/
////////////////////////////////////////////////////////////////////////////////
bool Window::RegisterWndClass(HINSTANCE hInstance)
{
    WNDCLASS wc;

    // fill out the window style structure...mostly default options
    wc.style = CS_DBLCLKS;          
    wc.lpfnWndProc = MyWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = NULL;
    wc.hCursor = LoadCursor(NULL, IDC_CROSS);
    wc.hbrBackground = (HBRUSH)::GetStockObject(WHITE_BRUSH);//(HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = mClassName.c_str();

    if (!::RegisterClass(&wc))
        return false;

    return true;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Un-registers the WNDCLASS with Windows
*/
////////////////////////////////////////////////////////////////////////////////
void Window::UnregisterWndClass()
{
    ::UnregisterClass(mClassName.c_str(), mWindowInstance);
} 

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Creates the Window
    @param	hInstance
            Windows window instance
    @param	windowName
            The name of the window
    @param	width
            Width of the Window
    @param	height
            Height of the Window
    @return	true if the Window creation was successful, false if not
    @par	This must be called to complete initialization of the Window object
*/
////////////////////////////////////////////////////////////////////////////////
bool Window::Create(HINSTANCE hInstance, const std::string & windowName, const unsigned int width, const unsigned int height)
{
    if(!RegisterWndClass(hInstance))
        return false;

    HMENU hMenu = ::LoadMenu(hInstance, MAKEINTRESOURCE(IDR_MENU1));
    SetMenuItem(hMenu, LINE_DDA, MF_CHECKED);

    mHwnd = ::CreateWindow(mClassName.c_str(),          // Window class name
                        windowName.c_str(),             // Window text (title)
                        WS_OVERLAPPEDWINDOW, // Window style
                        CW_USEDEFAULT,       // Let Windows decide
                        CW_USEDEFAULT,       // Let Windows decide
                        width,			 // Window size x
                        height,			 // Window size y
                        NULL,                // No parent window
                        hMenu,                // App's menu
                        hInstance,           // App's HINSTANCE
                        NULL);               // No data to WM_CREATE

    if(NULL == mHwnd)
        return false;

    gHwnd = mHwnd;  // Store the window handle globally

    mHdc = ::GetDC(mHwnd);
    ::ShowWindow(mHwnd, SW_SHOWNORMAL);

    // Define the array of TBBUTTON structures
    TBBUTTON tbButtons[] = {
        { MAKELONG(0, 0), ID_PRIMITIVE_LINE, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, (INT_PTR)L"Line" },
        { MAKELONG(1, 0), ID_PRIMITIVE_VECTOR, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, (INT_PTR)L"Vector" },
        { MAKELONG(2, 0), ID_SHAPE_TRIANGLE, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, (INT_PTR)L"Triangle" },
        { MAKELONG(3, 0), ID_SHAPE_RECTANGLE, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, (INT_PTR)L"Rectangle" },
        { MAKELONG(4, 0), ID_SHAPE_CIRCLE, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, (INT_PTR)L"Circle" },
        { MAKELONG(5, 0), ID_SHAPE_ELLIPSE, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, (INT_PTR)L"Ellipse" }
    };

    INITCOMMONCONTROLSEX icex;
    icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
    icex.dwICC = ICC_BAR_CLASSES; // Load toolbar and rebar controls
    InitCommonControlsEx(&icex);

    mHtoolbar = CreateToolbarEx(
        mHwnd,                      // Handle to the parent window
        WS_CHILD | WS_VISIBLE,      // Toolbar styles
        IDR_TOOLBAR1,               // Toolbar resource ID
        7,                          // Number of buttons
        hInstance,                  // Handle to the application instance
        IDB_TOOLBAR,                // Bitmap resource ID
        tbButtons,                  // Array of TBBUTTON structures
        sizeof(tbButtons) / sizeof(TBBUTTON),
        16, 16,                     // Width and height of buttons
        16, 16,                     // Width and height of bitmaps
        sizeof(TBBUTTON)            // Size of a TBBUTTON structure
    );

    ::ShowWindow(mHtoolbar, SW_SHOW);

    mRunning = true;
    mWidth = width;
    mHeight = height;
    mWindowInstance = hInstance;

    // Create the secondary buffer
    CreateSecondaryBuffer(width, height);
    memset(mSurface, 0xFF, sizeof(int) * Width() * Height());   // Set the back surface to white

    return true;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Creates a secondary rendering buffer
    @param	width
            Width of the secondary buffer
    @param	height
            Height of the secondary buffer
*/
////////////////////////////////////////////////////////////////////////////////
void Window::CreateSecondaryBuffer(const unsigned int width, const unsigned int height)
{
    BITMAPINFOHEADER bmpinfo;
    bmpinfo.biBitCount = 32;
    bmpinfo.biClrImportant = 0;
    bmpinfo.biClrUsed = 0;
    bmpinfo.biCompression = BI_RGB;
    bmpinfo.biHeight = height;
    bmpinfo.biPlanes = 1;
    bmpinfo.biSize = sizeof(BITMAPINFOHEADER);
    bmpinfo.biSizeImage = 0;
    bmpinfo.biWidth = width;
    bmpinfo.biXPelsPerMeter = 0;
    bmpinfo.biYPelsPerMeter = 0;

    HDC tmpDC = ::CreateDC("Display", 0, 0, 0);
    mBitmapDC = ::CreateCompatibleDC(tmpDC);

    // if mBitmapDC is null, something very bad hapened
    mBitmap = ::CreateDIBSection(mBitmapDC, (BITMAPINFO *)&bmpinfo, DIB_RGB_COLORS, (void **)&mSurface, NULL, NULL);
    
    mOldBitmap = (HBITMAP)SelectObject(mBitmapDC, mBitmap);

    ::DeleteDC(tmpDC);
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Swaps the primary and secondary buffer by blitting to the primary surface
    @par	Has a side effect of clearing the screen after blitting
*/
////////////////////////////////////////////////////////////////////////////////
void Window::Present()
{
    RECT rect;
    GetClientRect(gHwnd, &rect);
    SetTextColor(mBitmapDC, RGB(0, 0, 0));
    DrawText(mBitmapDC, gFirstPosStr.c_str(), -1, &rect, DT_BOTTOM | DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
    DrawText(mBitmapDC, gMousePosStr.c_str(), -1, &rect, DT_BOTTOM | DT_CENTER | DT_SINGLELINE | DT_NOCLIP);

    BitBlt(mHdc, 0, 0, Width(), Height(), mBitmapDC, 0, 0, SRCCOPY);
    memset(mSurface, 0xFF, sizeof(int) * Width() * Height());
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Sets a pixel on the back buffer surface
    @param	x
            X coordinate of the pixel
    @param	y
            Y coordinate of the pixel
    @param	color
            Color of the pixel
*/
////////////////////////////////////////////////////////////////////////////////
void Window::SetPixel(const unsigned int x, const unsigned int y, const Color & color) const
{
    if( (x < Width() && x > 0) && (y < Height() && y > 0) )
    {
        unsigned int fnlcolor = 0;
        fnlcolor = color.GetR() << 16;
        fnlcolor = (color.GetG() << 8) | fnlcolor;
        fnlcolor = color.GetB() | fnlcolor;

        // Note: y is flipped b/c Windows stores bitmaps upside down
        *(mSurface + ((Height() - y) * Width()) + x) = fnlcolor; 
    }
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Processes messages from Windows
    @par	Sets the internal running state to false if a close message is 
            in the queue.
*/
////////////////////////////////////////////////////////////////////////////////
void Window::ProcessMessages() 
{
    MSG msg;
    if(::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    {
        // Signal that the window should be terminated on a quit message
        if(WM_QUIT == msg.message)
            mRunning = false;
            
        ::TranslateMessage(&msg);
        ::DispatchMessage(&msg);
    }
}


}	// namespace CGF


////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Checks if a menu item is active
    @param	menuItem
            The menu item to check for
    @return	true if the menu item is set to active, false if not
*/
////////////////////////////////////////////////////////////////////////////////
bool IsMenuItemActive(const enum MENU_ITEM menuItem)
{
    // Check if the specified menu was set
    return menuChecked[menuItem];
}

void ClearFirstPoint()
{
    ClearPreviousPoint();
    gFirstPosStr.clear();
}

void SetFirstPoint(unsigned int x, unsigned int y)
{
    SetPreviousPoint(x, y);
    gFirstPosStr = gFirstPosPrefix + gPosPrefix + std::to_string(x) + gPosSeparator + std::to_string(y) + gPosSuffix;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Sets a menu item in a menu to active or inactive (checked or unchecked)
    @param	hMenu
            The menu
    @param	menuItem
            The menu item to check for
    @param	check
            The state of the menu item
*/
////////////////////////////////////////////////////////////////////////////////
void SetMenuItem(HMENU hMenu, MENU_ITEM menuItem, UINT check)
{
    menuChecked[menuItem] = (check == MF_CHECKED);

    switch (menuItem)
    {
    case LINE_DDA:
        CheckMenuItem(hMenu, ID_LINE_DRAW_DDA, check);
        break;
    
    case LINE_BRESENHAM:
        CheckMenuItem(hMenu, ID_LINE_DRAW_BRESENHAM, check);
        break;
    
    case LINE_ANIMATE:
        CheckMenuItem(hMenu, ID_LINE_ANIMATE, check);
        break;
    
    case OBJECT_CIRCLE:
        CheckMenuItem(hMenu, ID_SHAPE_CIRCLE, check);
        break;

    case OBJECT_ELLIPSE:
        CheckMenuItem(hMenu, ID_SHAPE_ELLIPSE, check);
        break;
    
    default:
        throw std::exception("Invalid menu item");
    }
}

void SetMousePosStr(DWORD x, DWORD y)
{
    gMousePosStr = gPosPrefix + std::to_string(x) + gPosSeparator + std::to_string(y) + gPosSuffix;
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	Window Procedure
    @param	hwnd
            Window handle
    @param	msg
            Incoming message
    @param	wParam
            Message data
    @param	lParam
            Message data
    @return	Result of the callback
*/
////////////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK MyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    // Required for constructing a polyline ...
    static int firstTime = 1;
    static CGF::Point2D firstPoint;
    static CGF::Point2D majorAxis;
    static CGF::Point2D minorAxis;

    PAINTSTRUCT ps;

    // Check the message type
    switch (msg)
    {
        // Re-sizing the window
        case WM_SIZING:
        {
           // Prevent window re-sizing
           // @bug -- Using this technique causes the window to collapse
           /*RECT * newArea = reinterpret_cast<RECT *>(lParam);
           RECT clientArea; 
           ::GetClientRect(gHwnd, &clientArea);
           clientArea.right += 8;    // pixel border
           clientArea.bottom += 34;
            
           if(newArea)
               *newArea = clientArea;
           */
           return TRUE;
        }

        // Handle the mousemove message
        case WM_MOUSEMOVE:
            SetMousePosStr(LOWORD(lParam), HIWORD(lParam));
            return 0;
                    
        // Handle left mouse button clicks
        // Left mouse button clicks in active region of window
        // create a polyline ...
        case WM_LBUTTONDOWN:
        {
            // Add the point to the point list
            unsigned int x = LOWORD(lParam);
            unsigned int y = HIWORD(lParam);

            if (IsMenuItemActive(LINE_DDA) || IsMenuItemActive(LINE_BRESENHAM))
            {
                if (firstTime)
                {
                    firstPoint = CGF::Point2D(x, y);
                    SetFirstPoint(x, y);
                    firstTime = 0;
                }
                else
                {
                    CGF::Point2D secondPoint(x, y);
                    
                    // Create a polyline whose start point is defined by firstPoint and
                    // end point is defined by second point and default color is black
                    CGF::Line2D l(firstPoint, secondPoint, CGF::Color(0,0,0,255));
                    
                    // Add line to list
                    AddLine2D(l);

                    // A line also defines an animated box object whose default width and height
                    // are both 40 and whose initial center is the start point of the line.
                    // The box bounces between the first and second points with a default
                    // green fill color.
                    extern CGF::Color grnClr; // defined in Main.cpp
                    AddBox2D(CGF::Box2D (40, 40, firstPoint, secondPoint, 300, grnClr));
                    
                    firstPoint = secondPoint;
                    SetFirstPoint(x, y);
                }
            }
            else if (IsMenuItemActive(OBJECT_CIRCLE))
            {
                if (firstTime) // first point, set the center point
                {
                    firstPoint = CGF::Point2D(x, y);
                    SetFirstPoint(x, y);
                    firstTime = 0;
                }
                else // second point, set the radius
                {
                    CGF::Point2D secondPoint(x, y);
                    float radius = CGF::Vector2D(firstPoint, secondPoint).magnitude();

                    // Create a circle with the first point as the center and the distance to the second point as the radius
                    CGF::Circle c(firstPoint, radius);
                    
                    // Add circle to list
                    AddCircle(c);
                    
                    firstTime = 1;
                    ClearFirstPoint();
                }
            }
            else if (IsMenuItemActive(OBJECT_ELLIPSE))
            {
                if (firstTime == 1)
                {
                    // Set the center point
                    firstPoint = CGF::Point2D(x, y);
                    SetFirstPoint(x, y);
                    firstTime = 2;
                }
                else if (firstTime == 2)
                {
                    // Set the major axis
                    majorAxis = CGF::Point2D(x, y);
                    firstTime = 3;
                }
                else if (firstTime == 3)
                {
                    // Set the minor axis
                    minorAxis = CGF::Point2D(x, y);
                    
                    // Create an ellipse with the first point as the center and the distance to the second point as the major axis
                    CGF::Ellipse e(firstPoint, majorAxis, minorAxis);
                    
                    // Add ellipse to list
                    AddEllipse(e);
                    
                    firstTime = 1;
                    ClearFirstPoint();
                }
            }

            return 0;
        }

        // Handle the keydown message
        case WM_KEYDOWN:
        {
            // The keycode is specified by the wParam
            switch(wParam)
            {
                // Windows does not define symbols for these keys.
                // Use the 'C' key to clear the line list.
                // 'C' is 0x43
                case 0x43:      // 'C' key
                {
                    ClearLine2D();
                    ClearBox2D();
                    ClearCircle();
                    ClearEllipse();
                    ClearFirstPoint();
                    firstTime = 1;
                    break;
                }
            }
            return 0;
        }

        // Handle messages from the Menu bar
        case WM_COMMAND:
        {
            // Get a handle to the menu
            HMENU hMenu = ::GetMenu(gHwnd);
            switch(LOWORD(wParam))
            {
                case ID_LINE_DRAW_DDA:
                    {
                        if (IsMenuItemActive(LINE_DDA))
                        {
                            SetMenuItem(hMenu, LINE_DDA, MF_UNCHECKED);
                        }
                        else
                        {
                            SetMenuItem(hMenu, LINE_DDA, MF_CHECKED);
                            SetMenuItem(hMenu, LINE_BRESENHAM, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_CIRCLE, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_ELLIPSE, MF_UNCHECKED);
                        }
                        break;
                    }

                case ID_LINE_DRAW_BRESENHAM:
                    {
                        if (IsMenuItemActive(LINE_BRESENHAM))
                        {
                            SetMenuItem(hMenu, LINE_BRESENHAM, MF_UNCHECKED);
                        }
                        else
                        {
                            SetMenuItem(hMenu, LINE_BRESENHAM, MF_CHECKED);
                            SetMenuItem(hMenu, LINE_DDA, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_CIRCLE, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_ELLIPSE, MF_UNCHECKED);
                        }
                        break;
                    }
                case ID_LINE_ANIMATE:
                    {
                        // Toggle the Animate menu item
                        if (IsMenuItemActive(LINE_ANIMATE))
                        {
                            SetMenuItem(hMenu, LINE_ANIMATE, MF_UNCHECKED);
                        }
                        else
                        {
                            SetMenuItem(hMenu, LINE_ANIMATE, MF_CHECKED);
                            SetMenuItem(hMenu, OBJECT_CIRCLE, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_ELLIPSE, MF_UNCHECKED);
                        }
                        break;
                    }
                case ID_SHAPE_CIRCLE:
                    {
                        // Toggle the Circle menu item
                        if (IsMenuItemActive(OBJECT_CIRCLE))
                        {
                            SetMenuItem(hMenu, OBJECT_CIRCLE, MF_UNCHECKED);
                        }
                        else
                        {
                            ClearFirstPoint();
                            firstTime = 1;
                            SetMenuItem(hMenu, LINE_DDA, MF_UNCHECKED);
                            SetMenuItem(hMenu, LINE_BRESENHAM, MF_UNCHECKED);
                            SetMenuItem(hMenu, LINE_ANIMATE, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_CIRCLE, MF_CHECKED);
                            SetMenuItem(hMenu, OBJECT_ELLIPSE, MF_UNCHECKED);
                        }
                        break;
                    }
                case ID_SHAPE_ELLIPSE:
                    {
                        // Toggle the Ellipse menu item
                        if (IsMenuItemActive(OBJECT_ELLIPSE))
                        {
                            SetMenuItem(hMenu, OBJECT_ELLIPSE, MF_UNCHECKED);
                        }
                        else
                        {
                            ClearFirstPoint();
                            firstTime = 1;
                            SetMenuItem(hMenu, LINE_DDA, MF_UNCHECKED);
                            SetMenuItem(hMenu, LINE_BRESENHAM, MF_UNCHECKED);
                            SetMenuItem(hMenu, LINE_ANIMATE, MF_UNCHECKED);
                            SetMenuItem(hMenu, OBJECT_ELLIPSE, MF_CHECKED);
                            SetMenuItem(hMenu, OBJECT_CIRCLE, MF_UNCHECKED);
                        }
                        break;
                    }
                case ID_HELP_ABOUT:
                    {
                        // Simple about box - modal 
                        MessageBox(gHwnd, "Developer :: Willow Hayward", "Computer Graphics Framework", MB_OK);
                        break;
                    }
            }
            return 0;
        }

        // Paint message
        case WM_PAINT:
        {
            BeginPaint(hwnd, &ps);
            EndPaint(hwnd, &ps);
            return 0;
        }

        // Destroy message
        case WM_DESTROY:
            return 0;

        // Close message
        case WM_CLOSE:
            PostQuitMessage(0);
            return 0;

        // Default handling
        default:
            break;
    }

    // Dispatch any unhandled messages
    return DefWindowProc(hwnd, msg, wParam, lParam);
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	floating point rounding operation
    @param	n
            the float
    @return	the integer that the float is closest to
*/
////////////////////////////////////////////////////////////////////////////////
int roundToInt(float n)
{
    return (int) (n < 0.0F ? ceil(n - 0.5F) : floor(n + 0.5F));
}

////////////////////////////////////////////////////////////////////////////////
/*!
    @brief	floating point rounding operation
    @param	n
            the float
    @return	the absolute value of the integer that the float is closest to
*/
////////////////////////////////////////////////////////////////////////////////
unsigned int roundToUInt(float n)
{
    return (unsigned int) abs(roundToInt(n));
}