E:/Eigene Dateien/Eigene Projekte/c0re/Window.cpp

Go to the documentation of this file.

/*
        This file is part of c0re.

        c0re is a multiplayer RTS on a hexagonal map with an evolving unit concept.
    Copyright (C) 2007 Stephan Hofmann

    c0re is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "Window.h"

#include <iostream>

std::map<HWND, Window*> Window::openWindows;

Window::Window()
{

        scancodes[27] = "ESC";
        scancodes[33] = "PGUP";
        scancodes[34] = "PGDOWN";
        scancodes[37] = "LEFTARROW";
        scancodes[38] = "UPARROW";
        scancodes[39] = "RIGHTARROW";
        scancodes[40] = "DOWNARROW";
        scancodes[32] = "SPACE";
        scancodes[13] = "RETURN";
        scancodes[8]  = "BACKSPACE";
        for (int i = 65; i <= 90; i++)
                scancodes[i] = (char)i;
}

Window::~Window()
{
}
int Window::checkMessages()
{
        int ret = 0;
        MSG msg;
        while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))                    // Is There A Message Waiting?
        {
                {
                        TranslateMessage(&msg);                         // Translate The Message
                        DispatchMessage(&msg);                          // Dispatch The Message
                }
                if (msg.message == WM_QUIT)
                {
                        ret = 1;
                }
        }
        return ret;
}

int Window::clearCurrent()
{
        int ret = 0;

        if (!wglMakeCurrent (0, 0))
        {
                //std::cout << (DWORD)GetLastError() << std::endl;
                ret = -1;
        }

        return ret; 
}

HWND Window::createWindow(std::string name, int p_height, int p_width, int depth, bool p_fullscreen)
{
        HWND ret;
        fullscreen = p_fullscreen;
        height = p_height;
        width = p_width;

        DWORD           dwExStyle;                                              // Window Extended Style
        DWORD           dwStyle;
        RECT WindowRect;                                                        // Grabs Rectangle Upper Left / Lower Right Values
        WindowRect.left=(long)0;                                                // Set Left Value To 0
        WindowRect.right=(long)width;                                           // Set Right Value To Requested Width
        WindowRect.top=(long)0;                                                 // Set Top Value To 0
        WindowRect.bottom=(long)height; 
        hInstance               = GetModuleHandle(NULL);


        WNDCLASS        wc;
        wc.style                = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;           // Redraw On Move, And Own DC For Window
        wc.lpfnWndProc          = (WNDPROC) this->WndProc;                              // WndProc Handles Messages
        wc.cbClsExtra           = 0;                                            // No Extra Window Data
        wc.cbWndExtra           = 0;                                            // No Extra Window Data
        wc.hInstance            = hInstance;                                    // Set The Instance
        wc.hIcon                = LoadIcon(NULL, IDI_WINLOGO);                  // Load The Default Icon
        wc.hCursor              = LoadCursor(NULL, IDC_ARROW);                  // Load The Arrow Pointer
        wc.hbrBackground        = NULL;                                         // No Background Required For GL
        wc.lpszMenuName         = NULL;                                         // We Don't Want A Menu
        wc.lpszClassName        = "OpenGL";                                     // Set The Class Name

        if (!RegisterClass(&wc))                                                // Attempt To Register The Window Class
        {
                //MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
                return 0;                                                               // Exit And Return FALSE
        }

        if (fullscreen)                                                         // Attempt Fullscreen Mode?
        {
                DEVMODE dmScreenSettings;                                       // Device Mode
                memset(&dmScreenSettings,0,sizeof(dmScreenSettings));           // Makes Sure Memory's Cleared
                dmScreenSettings.dmSize=sizeof(dmScreenSettings);               // Size Of The Devmode Structure
                dmScreenSettings.dmPelsWidth    = width;                        // Selected Screen Width
                dmScreenSettings.dmPelsHeight   = height;                       // Selected Screen Height
                dmScreenSettings.dmBitsPerPel   = depth;                                // Selected Bits Per Pixel
                dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

                // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
                if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
                {
                        // If The Mode Fails, Offer Two Options.  Quit Or Run In A Window.
                        if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
                        {
                                fullscreen=FALSE;                               // Select Windowed Mode (Fullscreen=FALSE)
                                
                        }
                        else
                        {
                                // Pop Up A Message Box Letting User Know The Program Is Closing.
                                //MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
                                return 0;                                               // Exit And Return FALSE
                        }
                }
        }


        if (fullscreen)                                                         // Are We Still In Fullscreen Mode?
        {
                dwExStyle=WS_EX_APPWINDOW;                                      // Window Extended Style
                dwStyle=WS_POPUP;                                               // Windows Style
                //ShowCursor(FALSE);                                            // Hide Mouse Pointer
        }
        else
        {
                dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;                   // Window Extended Style
                dwStyle=WS_OVERLAPPEDWINDOW;                                    // Windows Style
        }

        if (!(hWnd=CreateWindowEx(      
                                dwExStyle,                              // Extended Style For The Window
                                "OpenGL",                               // Class Name
                                name.c_str(),                                   // Window Title
                                WS_CLIPSIBLINGS |                       // Required Window Style
                                WS_CLIPCHILDREN |                       // Required Window Style
                                dwStyle,                                // Selected Window Style
                                0, 0,                                   // Window Position
                                WindowRect.right-WindowRect.left,       // Calculate Adjusted Window Width
                                WindowRect.bottom-WindowRect.top,       // Calculate Adjusted Window Height
                                NULL,                                   // No Parent Window
                                NULL,                                   // No Menu
                                hInstance,                              // Instance
                                NULL)))                                 // Don't Pass Anything To WM_CREATE
        {
                killWindow();                                                   // Reset The Display
                //MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
                return 0;                                               // Return FALSE
        }
        else
                ret = hWnd;

        openWindows.insert(std::make_pair(hWnd, this));

        hDC = GetDC(hWnd);

        PIXELFORMATDESCRIPTOR pfd ;
        memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)) ;
        pfd.nSize      = sizeof(PIXELFORMATDESCRIPTOR); 
        pfd.nVersion   = 1 ; 
        pfd.dwFlags    = PFD_DOUBLEBUFFER |
                                        PFD_SUPPORT_OPENGL |
                                        PFD_DRAW_TO_WINDOW ;
        pfd.iPixelType = PFD_TYPE_RGBA ;
        pfd.cColorBits = depth ;
        pfd.cDepthBits = depth ;
        pfd.iLayerType = PFD_MAIN_PLANE ;

        int nPixelFormat = ChoosePixelFormat(hDC, &pfd);
        if (nPixelFormat == 0)
        {
                //std::cout <<"ChoosePixelFormat Failed \n";
                return 0;
        }
        std::cout << "Pixel Format: "<<nPixelFormat << std::endl;

        BOOL bResult = SetPixelFormat (hDC, nPixelFormat, &pfd);
        if (!bResult)
        {
                //std::cout << "SetPixelFormat Failed \n";
                return 0;
        }

        hRC = wglCreateContext(hDC);
        if (!hRC)
        {
                //std::cout << "wglCreateContext Failed\n";
                return 0;
        }

        ShowWindow(hWnd,SW_SHOW);                                               // Show The Window
        SetForegroundWindow(hWnd);                                              // Slightly Higher Priority
        SetFocus(hWnd);
        return ret;

}

int Window::killWindow()
{
        int ret = 0;

        if (fullscreen)                                                         // Are We In globals.int_fullscreen Mode?
        {

                ChangeDisplaySettings(NULL,0);                                  // If So Switch Back To The Desktop
                ShowCursor(TRUE);                                               // Show Mouse Pointer
        }

        if (hRC)                                                                // Do We Have A Rendering Context?
        {
                if (!wglDeleteContext(hRC))                                     // Are We Able To Delete The RC?
                {
                        //MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
                        return -1;
                }
                hRC=NULL;                                                       // Set RC To NULL
        }

        if (hDC && !ReleaseDC(hWnd,hDC))                                        // Are We Able To Release The DC
        {
                //MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
                hDC=NULL;                                                       // Set DC To NULL
                return -1;
        }

        openWindows.erase(hWnd);

        if (hWnd && !DestroyWindow(hWnd))                                       // Are We Able To Destroy The Window?
        {
                //MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
                hWnd=NULL;                                                      // Set hWnd To NULL
                return -1;
        }

        return ret;

}

int Window::makeCurrent()
{
        int ret = 0;

        if (!wglMakeCurrent (hDC, hRC))
        {
                //std::cout << (DWORD)GetLastError() << std::endl;
                return -1;
        }

        return ret;
}

int Window::swapBuffers()
{
        int ret = 0;

        if (!SwapBuffers(hDC))
                return -1;

        return ret;
}

void Window::switchFullscreen()
{
}


int Window::BuildFont()                                                         // Build Our Bitmap Font
{
        HFONT   font;                                                                           // Windows Font ID
        HFONT   oldfont;                                                                        // Used For Good House Keeping

        int base = -100; //glGenLists(96);                                                              // Storage For 96 Characters

        font = CreateFont(      25,                                                             // Height Of Font
                                                0,                                                              // Width Of Font
                                                0,                                                              // Angle Of Escapement
                                                0,                                                              // Orientation Angle
                                                700,                                                    // Font Weight
                                                FALSE,                                                  // Italic
                                                FALSE,                                                  // Underline
                                                FALSE,                                                  // Strikeout
                                                ANSI_CHARSET,                                   // Character Set Identifier
                                                OUT_TT_PRECIS,                                  // Output Precision
                                                CLIP_DEFAULT_PRECIS,                    // Clipping Precision
                                                ANTIALIASED_QUALITY,                    // Output Quality
                                                FF_DONTCARE|DEFAULT_PITCH,              // Family And Pitch
                                                "Courier New");                                 // Font Name

        oldfont = (HFONT)SelectObject(hDC, font);           // Selects The Font We Want
        wglUseFontBitmaps(hDC, 32, 96, base);                           // Builds 96 Characters Starting At Character 32
        SelectObject(hDC, oldfont);                                                     // Selects The Font We Want
        DeleteObject(font);                                                                     // Delete The Font
        return base;
}

/******************** END OF CLASS WindowWindow ***********************/

LRESULT CALLBACK Window::WndProc(       HWND    hWnd,                                   // Handle For This Window
                                UINT    uMsg,                                   // Message For This Window
                                WPARAM  wParam,                                 // Additional Message Information
                                LPARAM  lParam)                                 // Additional Message Information
{
        switch (uMsg)                                                           // Check For Windows Messages
        {
                case WM_SYSCOMMAND:                                             // Intercept System Commands
                {
                        switch (wParam)                                         // Check System Calls
                        {
                                case SC_SCREENSAVE:                             // Screensaver Trying To Start?
                                case SC_MONITORPOWER:                           // Monitor Trying To Enter Powersave?
                                return 0;                                       // Prevent From Happening
                        }
                        break;                                                  // Exit
                }
                case WM_CLOSE:                                                  // Did We Receive A Close Message?
                {
                        PostQuitMessage(0);                                     // Send A Quit Message
                        return 0;                                               // Jump Back
                }
                case WM_KEYDOWN:                                                // Is A Key Being Held Down?
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                std::map<int, std::string>::iterator it = wnd->scancodes.find((int)wParam);
                                if (it != wnd->scancodes.end())
                                {
                                        wnd->pushMessage("+" + it->second);
                                }
                        }
                        return 0;                                               // Jump Back
                }
                case WM_KEYUP:                                                  // Has A Key Been Released?
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                std::map<int, std::string>::iterator it = wnd->scancodes.find((int)wParam);
                                if (it != wnd->scancodes.end())
                                {
                                        wnd->pushMessage("-" + it->second);
                                }
                        }
                        return 0;                                               // Jump Back
                }
                case WM_SIZE:                                                   // Resize The OpenGL Window
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                wnd->height = HIWORD(lParam);
                                (wnd->height == 0)?wnd->height = 1 : 1;
                                wnd->width = LOWORD(lParam);            // LoWord=Width, HiWord=Height
                        }
                        return 0;                                               // Jump Back
                }
                case WM_MOUSEMOVE:
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                wnd->mousePos = Vector3i(LOWORD(lParam), wnd->height - HIWORD(lParam), 0);
                        }
                        return 0;                                               // Jump Back
                }
                case WM_MOUSEWHEEL:
                {
                        int zDelta;
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
                                if (zDelta > 0)
                                {
                                        wnd->pushMessage("+WMouse");
                                }
                                else 
                                {
                                        wnd->pushMessage("-WMouse");
                                }
                        }
                        return 0;                                               // Jump Back
                }
                case WM_LBUTTONDOWN:
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                wnd->pushMessage("+LMOUSE");
                        }
                        return 0;                                               // Jump Back
                }
                case WM_LBUTTONUP:
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                wnd->pushMessage("-LMOUSE");
                        }
                        return 0;                                               // Jump Back
                }
                case WM_RBUTTONDOWN:
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                TRACKMOUSEEVENT tme;
                                tme.cbSize = sizeof(tme); 
                tme.dwFlags = TME_LEAVE; 
                tme.hwndTrack = hWnd; 
                TrackMouseEvent(&tme);
                                Window* wnd = it->second;
                                wnd->pushMessage("+RMOUSE");
                        }
                        return 0;                                               // Jump Back
                }
                case WM_RBUTTONUP:
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                wnd->pushMessage("-RMOUSE");
                        }
                        return 0;                                               // Jump Back
                }
                case WM_MOUSELEAVE:
                {
                        std::map<HWND,Window*>::iterator it;
                        it = openWindows.find(hWnd);
                        if (it != openWindows.end())
                        {
                                Window* wnd = it->second;
                                wnd->pushMessage("-RMOUSE");
                                wnd->pushMessage("-LMOUSE");
                        }
                        return 0;                                               // Jump Back
                }
        }

        // Pass All Unhandled Messages To DefWindowProc
        return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

---