fs/rap/fsWinApp.cpp

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*     [fsWinApp]         / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev. 4          / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    9th Feb 2007      /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [ ] stable              /_/ (c) 2006-7 Filip STOKLAS (FipS)         */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~       http://HOLE.4FipS.com/fips_code.php          */
/*                                                                         */
/* This code is free for personal and commercial use. You may redistribute */
/* it by any means. If you use the code for your own projects please give  */
/* me credit. Please send a bug report. Don't alter or remove this header! */
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <fs/rap/fsWinApp.h>

// >>> COMMON SUPPORT BLOCK (rev. 6)
#if defined(FS_HAS_FSASSERT)
#   include <fs/sys/fsAssert.h>
#else
#   include <cassert>
#   if !defined(FS_ASSERT)
#       define FS_ASSERT(exp) assert(exp)
#   endif
#   if !defined(FS_ASSERT_MSG)
#       define FS_ASSERT_MSG(exp, msg) assert(exp && msg)
#   endif
#   if !defined(FS_VERIFY)
#       define FS_VERIFY(exp) \
        { bool bExp = !!(exp); assert(bExp && #exp); bExp; }
#   endif
#   if !defined(FS_VERIFY_MSG)
#       define FS_VERIFY_MSG(exp, msg) \
        { bool bExp = !!(exp); assert(bExp && #exp && msg); bExp; }
#   endif
#   if !defined(FS_STATIC_ASSERT)
#       define FS_STATIC_ASSERT(exp) { char error[(exp) ? 1 : 0]; error; }
#   endif
#endif
#if !defined(FS_VERIFY_RETURN)
#   define FS_VERIFY_RETURN(exp) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<return>"); return; }
#endif
#if !defined(FS_VERIFY_RETURN_VAL)
#   define FS_VERIFY_RETURN_VAL(exp, ret) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<returns:>" #ret); return (ret); }
#endif
// <<< COMMON SUPPORT BLOCK (rev. 6)

#include <vector>
#include <windows.h>

// provide detailed memory tracking information
#if defined(FS_HAS_FSMEMMGR)
#   include <fs/sys/fsMemMgr.h>
#endif
//---------------------------------------------------------------------------
using namespace fs::rap;
//---------------------------------------------------------------------------
namespace fs { namespace rap {
//---------------------------------------------------------------------------
WinApp_t & WinAppInst()
{
    static WinApp_t Inst;
    return Inst;
}
//---------------------------------------------------------------------------
}} // namespace fs::rap
//---------------------------------------------------------------------------
//--- ANONYMOUS NAMESPACE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
namespace {
//---------------------------------------------------------------------------
WinApp_t::InitCfg_t g_Cfg;
const char *g_pszCmdLine = 0;
HWND g_hWnd = 0; 
int g_nMouseX = 0, g_nMouseY = 0;
typedef std::vector<WinApp_t::EvRcvr_i *> TEvRcvrs;
TEvRcvrs g_EvRcvrs; 
bool g_bIgnSysEvs = true; 
//---------------------------------------------------------------------------
template <typename T>
void Send(T &Event)
{
    for(size_t i = 0; i < g_EvRcvrs.size(); ++i)
        g_EvRcvrs[i]->OnEvent(Event, WinAppInst());
}
//---------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if(g_bIgnSysEvs)
        return ::DefWindowProc(hWnd, msg, wParam, lParam);

    switch(msg)
    {
        case WM_MOUSEMOVE:
        {
            g_nMouseX = LOWORD(lParam);
            g_nMouseY = HIWORD(lParam);
            const WinApp_t::MouseEv_t MouseEv(g_nMouseX, g_nMouseY);
            
            Send(MouseEv);
            
            break;
        }
        case WM_PAINT:
        {
            const WinApp_t::DrawEv_t DrawEv;
            Send(DrawEv);
            
            // validate the whole cl. rect, prevent from recur. WM_PAINT
            ::ValidateRect(hWnd, 0);
            
            break;
        }
        case WM_KEYDOWN:
        {
            const WinApp_t::KeyEv_t KeyEv
             (static_cast<int>(wParam), true, g_nMouseX, g_nMouseY);
             
            Send(KeyEv);
                
            break;
        }
        case WM_KEYUP:
        {
            const WinApp_t::KeyEv_t KeyEv
             (static_cast<int>(wParam), false, g_nMouseX, g_nMouseY);
             
            Send(KeyEv);
                
            break;
        }
        case WM_LBUTTONDOWN:
        {
            const WinApp_t::KeyEv_t KeyEv
             (WinApp_t::KeyEv_t::KEY_LMBTN, true, g_nMouseX, g_nMouseY);
             
            Send(KeyEv);
                
            break;
        }
        case WM_LBUTTONUP:
        {
            const WinApp_t::KeyEv_t KeyEv
             (WinApp_t::KeyEv_t::KEY_LMBTN, false, g_nMouseX, g_nMouseY);
             
            Send(KeyEv);
                
            break;
        }
        case WM_SYSCHAR: // Alt + KEY
        {
            if(wParam == VK_RETURN)
            {
                WinAppInst().Fscrn(!g_Cfg.m_bFscrn);
            }
            break;
        }
        case WM_SIZE:
        {
            if(!g_Cfg.m_bFscrn)
            {
                g_Cfg.m_nClW = LOWORD(lParam);
                g_Cfg.m_nClH = HIWORD(lParam);
            }
        
            const WinApp_t::SizeEv_t SizeEv(LOWORD(lParam), HIWORD(lParam));
             
            Send(SizeEv);
                
            break;
        }
        case WM_CLOSE:
        {
            WinAppInst().Quit();
            
            break;
        }
            
        default:
            return ::DefWindowProc(hWnd, msg, wParam, lParam);
    };

    return 0;
}
//---------------------------------------------------------------------------
void GetWinStyles(const WinApp_t::InitCfg_t &Cfg, DWORD &dwStyle, DWORD
 &dwExStyle)
{
    if(Cfg.m_bFscrn)
    {
        dwStyle = WS_POPUP;
        dwExStyle = WS_EX_APPWINDOW;
    }
    else
    {
        dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
                                
        if(!Cfg.m_bSzbl)
        {
            dwStyle &= ~WS_MAXIMIZEBOX;
            dwStyle &= ~WS_SIZEBOX;
        }
        
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
    }
}
//---------------------------------------------------------------------------
void GetDeskSize(int &nDeskW, int &nDeskH)
{
    const HWND hWnd = ::GetDesktopWindow();
    FS_ASSERT(hWnd);
    
    RECT rc;
    ::GetWindowRect(hWnd, &rc);
    
    nDeskW = rc.right - rc.left;
    nDeskH = rc.bottom - rc.top;
}
//---------------------------------------------------------------------------
void CalcClientRect(const WinApp_t::InitCfg_t &Cfg, RECT &rcCl)
{
    // full-screen mode - fill the screen
    if(Cfg.m_bFscrn)
    {
        rcCl.left = 0;
        rcCl.top = 0;
    
        // user - change of the screen resolution is assumed
        if(Cfg.m_nFscrnW > 0 && Cfg.m_nFscrnH)
        {
            rcCl.right = Cfg.m_nFscrnW;
            rcCl.bottom = Cfg.m_nFscrnH;
        }
        // same as the desktop
        else
        {
            int nDeskW, nDeskH;
            GetDeskSize(nDeskW, nDeskH);
        
            rcCl.right = nDeskW;
            rcCl.bottom = nDeskH;
        }
    }
    // window mode - center the window
    else
    {
        int nDeskW, nDeskH;
        GetDeskSize(nDeskW, nDeskH);
        
        rcCl.left = nDeskW / 2 - Cfg.m_nClW / 2;
        rcCl.top = nDeskH / 2 - Cfg.m_nClH / 2;
        rcCl.right = rcCl.left + Cfg.m_nClW;
        rcCl.bottom = rcCl.top + Cfg.m_nClH;
    }
}
//---------------------------------------------------------------------------
void CalcWinRect(const WinApp_t::InitCfg_t &Cfg, RECT &rcWin)
{
    // get the styles
    DWORD dwStyle, dwExStyle;
    GetWinStyles(Cfg, dwStyle, dwExStyle);
    
    // get the client rectangle
    CalcClientRect(Cfg, rcWin);
    
    // convert client to window rectangle
    ::AdjustWindowRectEx(&rcWin, dwStyle, FALSE, dwExStyle);
}
//---------------------------------------------------------------------------
HWND CreateWin(const WinApp_t::InitCfg_t &Cfg)
{
    //---

    // get the window styles based on the config
    DWORD dwStyle, dwExStyle;
    GetWinStyles(Cfg, dwStyle, dwExStyle);
    
    // get the window rectangle based on the config
    RECT rcWin;
    CalcWinRect(Cfg, rcWin);

    //---
    
    const HINSTANCE hInst = ::GetModuleHandle(0);
    FS_ASSERT(hInst);
            
    WNDCLASS wc;

    wc.style         = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   = (WNDPROC)WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInst;
    wc.hIcon         = 0;
    wc.hCursor       = 0;
    wc.hbrBackground = Cfg.m_bClrBgr?(HBRUSH)::GetStockObject(BLACK_BRUSH):0;
    wc.lpszMenuName  = 0;
    wc.lpszClassName = TEXT("FS_RAP_WINAPP");
    
    if(!::RegisterClass(&wc))
    {
        FS_ASSERT_MSG(0, "Could not register application window class!");
        return false;
    }
    
    //---

    HWND hWnd = ::CreateWindowEx(
     dwExStyle,
     TEXT("FS_RAP_WINAPP"),
     TEXT("FS_RAP_WINAPP"),
     dwStyle,
     rcWin.left,
     rcWin.top,
     rcWin.right - rcWin.left,
     rcWin.bottom - rcWin.top,
     0,
     0,
     hInst,
     0
    );

    if(!hWnd)
    {
        FS_ASSERT_MSG(g_hWnd, "Could not create application window!");
        return false;
    }
    
    //---
    
    return hWnd;
}
//---------------------------------------------------------------------------
} // anonymous namespace
//---------------------------------------------------------------------------
//--- GLOBAL NAMESPACE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR pszCmdLine, int)
{
    g_pszCmdLine = pszCmdLine;
    FS_ASSERT(g_pszCmdLine);
    
    //---
        
    // user initialization
    if(!WinAppInit(WinAppInst(), g_Cfg))
        return 0;
    
    // system initialization
    g_hWnd = CreateWin(g_Cfg);
    if(!g_hWnd)
        return 0;
    
    //--- INIT SEQUENCE --- title -> INIT -> SIZE -> show -> (DRAW)
    
    // set the title of the window
    WinAppInst().SetTitle(g_Cfg.m_pszTitle);
        
    // send the 'Init' event
    const WinApp_t::InitEv_t InitEv;
    Send(InitEv);
    
    // send the 'Size' event
    RECT rcCl;
    ::GetClientRect(g_hWnd, &rcCl);
    const WinApp_t::SizeEv_t SizeEv
     (rcCl.right - rcCl.left, rcCl.bottom - rcCl.top);
    Send(SizeEv);
                            
    // show the window (invokes the 'Draw' event)
    ::ShowWindow(g_hWnd, SW_SHOW);
        
    g_bIgnSysEvs = false;
    
    //---
            
    if(g_Cfg.m_bRtm)
    {
        for(;;)
        {
            MSG msg;
            // note: WM_PAINT is not removed from the queue!
            while(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
            {
                if(msg.message == WM_QUIT)
                    return static_cast<int>(msg.wParam);

                ::TranslateMessage(&msg);
                ::DispatchMessage(&msg);
            }
            
            // do the real-time stuff here...
            const WinApp_t::RunEv_t RunEv;
            Send(RunEv);
        }
    }
    else
    {
        MSG msg;    
        while(::GetMessage(&msg, 0, 0, 0))
        {
            ::TranslateMessage(&msg);
            ::DispatchMessage(&msg);
        }
        
        // ::GetMessage has reached WM_QUIT message
        return static_cast<int>(msg.wParam);
    }
}
//---------------------------------------------------------------------------
//--- CLASS WinApp_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
bool WinApp_t::IsValid() const
{
    return g_hWnd ? true : false;
}
//---------------------------------------------------------------------------
const char * WinApp_t::GetCmdLine() const
{
    FS_ASSERT(g_pszCmdLine);
    
    return g_pszCmdLine;
}
//---------------------------------------------------------------------------
void WinApp_t::SetTitle(const char *pszTitle)
{
    FS_VERIFY_RETURN(IsValid());
    FS_VERIFY_RETURN(pszTitle);
    FS_ASSERT(g_hWnd);
    
    ::SetWindowTextA(g_hWnd, pszTitle);
}
//---------------------------------------------------------------------------
void WinApp_t::Redraw()
{
    FS_VERIFY_RETURN(IsValid());

    // invalidate the whole client rect, invokes WM_PAINT in the future
    FS_ASSERT(g_hWnd);
    ::InvalidateRect(g_hWnd, 0, true);
}
//---------------------------------------------------------------------------
void WinApp_t::Fscrn(bool bOn)
{
    FS_VERIFY_RETURN(IsValid());

    // modify the global config
    g_Cfg.m_bFscrn = bOn;
    
    //---
    
    // get the window styles based on the config
    DWORD dwStyle, dwExStyle;
    GetWinStyles(g_Cfg, dwStyle, dwExStyle);
    
    // get the window rectangle based on the config
    RECT rcWin;
    CalcWinRect(g_Cfg, rcWin);
    
    //---
    
    FS_ASSERT(g_hWnd);
    
    // modify window styles (is it safe to overwrite the states completely?)
    FS_VERIFY(::SetWindowLongPtr(g_hWnd, GWL_STYLE, dwStyle));
    FS_VERIFY(::SetWindowLongPtr(g_hWnd, GWL_EXSTYLE, dwExStyle));
        
    // modify window rectangle
    FS_VERIFY(::SetWindowPos(
     g_hWnd,
     0,
     rcWin.left, rcWin.top,
     rcWin.right - rcWin.left, rcWin.bottom - rcWin.top,
     SWP_SHOWWINDOW
    ));
            
    // redraw the desktop (it seems to be necessary)
    if(!g_Cfg.m_bFscrn) // return from the full-screen
    {
        const HWND hDeskWnd = ::GetDesktopWindow();
        FS_ASSERT(hDeskWnd);
        ::RedrawWindow(
         hDeskWnd, 0, 0,
         RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN
        );
    }
}
//---------------------------------------------------------------------------
void WinApp_t::Quit()
{
    FS_VERIFY_RETURN(IsValid());

    const WinApp_t::QuitEv_t QuitEv;
    Send(QuitEv);

    ::PostQuitMessage(0);
}
//---------------------------------------------------------------------------
void * WinApp_t::GetWinHdle() const
{
    FS_VERIFY_RETURN_VAL(IsValid(), 0);
    FS_ASSERT(g_hWnd);
    
    return g_hWnd;
}
//---------------------------------------------------------------------------
void WinApp_t::RegEvRcvr(EvRcvr_i *pEvRcvr)
{
    FS_VERIFY_RETURN(pEvRcvr);
    
    g_EvRcvrs.push_back(pEvRcvr);
}
//---------------------------------------------------------------------------

---

FipS' Code (Thu Feb 15 22:43:35 2007) - (c) Filip STOKLAS (FipS) - [ www ] [ Guest Book ]