fs/rap/fsConWin.cpp

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*     [fsConWin]         / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev. 4          / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    8th Feb 2007      /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [x] 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/fsConWin.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 <map>
#include <vector>
#include <string>
#include <windows.h>

// provide detailed memory tracking information
#if defined(FS_HAS_FSMEMMGR)
#   include <fs/sys/fsMemMgr.h>
#endif
//---------------------------------------------------------------------------
using namespace fs::rap;
//---------------------------------------------------------------------------
//--- ANONYMOUS NAMESPACE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
namespace {
//---------------------------------------------------------------------------
class ConWinImpl_t;

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wPrm, LPARAM lPrm);
LRESULT CALLBACK InWndProc(HWND hWnd, UINT msg, WPARAM wPrm, LPARAM lPrm);

// replacement for the Get/SetWindowLongPtr ugly technique
typedef std::pair<HWND, ConWinImpl_t *> THwnd2ConPair;
typedef std::map<HWND, ConWinImpl_t *> THwnd2ConMap;
THwnd2ConMap g_Hwnd2ConMap; 
//---------------------------------------------------------------------------
//--- CLASS ConWinImpl_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
class ConWinImpl_t
{
 public:
 
    explicit ConWinImpl_t(const char *pszTitle);
    ~ConWinImpl_t();
    bool IsValid() const;
    
    void Show(bool bShow);
    void SetPos(int nX, int nY, int nW, int nH);
    void Push(const char *pszText, bool bCmd = false);
    void RegTxtRcvr(ConWin_t::TxtRcvr_i *pRcvr);
    
 public: // WndProc
 
    void OnSize(int nW, int nH);
    void OnReturn();
    void OnPrevCmd();
    void OnNextCmd();
    bool IsInWin(HWND hWnd) const;
    WNDPROC GetOrigInWndProc() const;
                
 private:

    ConWinImpl_t(const ConWinImpl_t &); 
    ConWinImpl_t & operator = (const ConWinImpl_t &); 

    HWND InitMainWin();
    HFONT InitOutFnt();
    HWND InitOutWin(HWND hParWnd);
    HWND InitInWin(HWND hParWnd);
    void Send(const char *pszText, bool bCmd);
    
    //---
    
    bool m_bInited;
    HFONT m_hOutFnt;
    HWND m_hMainWnd;
    HWND m_hOutWnd;
    HWND m_hInWnd;
    WNDPROC m_pOrigInWndProc;
        
    typedef std::vector<ConWin_t::TxtRcvr_i *> TTxtRcvrs;
    TTxtRcvrs m_TxtRcvrs;
    
    typedef std::vector<std::string> THist;
    THist m_Hist;
    int m_nHistPos;
};
//---------------------------------------------------------------------------
ConWinImpl_t::ConWinImpl_t(const char *pszTitle):
m_hOutFnt(0),
m_bInited(false),
m_hMainWnd(0),
m_hOutWnd(0),
m_hInWnd(0),
m_nHistPos(-1),
m_pOrigInWndProc(0)
{
    //--- MAIN WINDOW ---
    
    HWND hMainWnd = InitMainWin();
    FS_ASSERT(hMainWnd);
    g_Hwnd2ConMap.insert(THwnd2ConPair(hMainWnd, this));
    
    FS_ASSERT(pszTitle);
    ::SetWindowTextA(hMainWnd, pszTitle);
    
    //--- OUTPUT AREA ---
    
    HFONT hOutFnt = InitOutFnt();
    FS_ASSERT(hOutFnt);
        
    HWND hOutWnd = InitOutWin(hMainWnd);
    FS_ASSERT(hOutWnd);
    ::SendMessage(hOutWnd, WM_SETFONT, reinterpret_cast<WPARAM>(hOutFnt),
     FALSE);
     
    //--- COMMAND-LINE ---
    
    HWND hInWnd = InitInWin(hMainWnd);
    FS_ASSERT(hInWnd);
    g_Hwnd2ConMap.insert(THwnd2ConPair(hInWnd, this));
    
#if defined(_MSC_VER) // MSVC - weird headers???
#   pragma warning(push)
#   pragma warning(disable: 4312)
#   pragma warning(disable: 4244)
#endif

    // subclass the input control
    m_pOrigInWndProc = reinterpret_cast<WNDPROC>(::GetWindowLongPtr(hInWnd,
     GWL_WNDPROC));
    FS_ASSERT(m_pOrigInWndProc);
    ::SetWindowLongPtr(hInWnd, GWL_WNDPROC, reinterpret_cast<LONG_PTR>
     (InWndProc));
     
#if defined(_MSC_VER) // MSVC
#   pragma warning(pop)
#endif
    
    //--- TRANSFER STATE ---
        
    m_hOutFnt = hOutFnt;
    m_hMainWnd = hMainWnd;
    m_hOutWnd = hOutWnd;
    m_hInWnd = hInWnd;
    m_bInited = true;
}
//---------------------------------------------------------------------------
ConWinImpl_t::~ConWinImpl_t()
{
    ::DestroyWindow(m_hMainWnd);
    ::DeleteObject(m_hOutFnt);
        
    g_Hwnd2ConMap.erase(m_hMainWnd);
    g_Hwnd2ConMap.erase(m_hInWnd);
}
//---------------------------------------------------------------------------
bool ConWinImpl_t::IsValid() const
{
    return m_bInited;
}
//---------------------------------------------------------------------------
void ConWinImpl_t::Show(bool bShow)
{
    if(bShow)
    {
        // set window focus to the command-line
        FS_ASSERT(m_hInWnd);
        ::SetFocus(m_hInWnd);
    
        // scroll to the end of the output area
        FS_ASSERT(m_hOutWnd);
        int nCount = static_cast<int>(::SendMessage(m_hOutWnd,
         EM_GETLINECOUNT, 0, 0));
        ::SendMessage(m_hOutWnd, EM_LINESCROLL, 0, nCount);
    }
    
    FS_ASSERT(m_hMainWnd);
    ::ShowWindow(m_hMainWnd, bShow ? SW_SHOW : SW_HIDE);
}
//---------------------------------------------------------------------------
void ConWinImpl_t::SetPos(int nX, int nY, int nW, int nH)
{
    FS_ASSERT(m_hMainWnd);
    ::SetWindowPos(m_hMainWnd, 0, nX, nY, nW, nH,
     SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER);
}
//---------------------------------------------------------------------------
void ConWinImpl_t::Push(const char *pszText,  bool bCmd)
{
    FS_ASSERT(m_hOutWnd);
    
    // inform listeners
    Send(pszText, bCmd);

    // keep 300 lines at max
    while(::SendMessage(m_hOutWnd, EM_GETLINECOUNT, 0, 0) > 300)
    {
        const int nLen = static_cast<int>(::SendMessage(m_hOutWnd,
         EM_LINELENGTH, 0, 0));
         
        ::SendMessage(m_hOutWnd, EM_SETSEL, 0, nLen + 2); // 2 means \r\n
        ::SendMessageA(m_hOutWnd, EM_REPLACESEL, 0, (LPARAM)"");
    }
    
    // reset the selection
    ::SendMessage(m_hOutWnd, EM_SETSEL, 65535 , 65535);

    // the first line => \r\n is not needed
    if(::SendMessage(m_hOutWnd, WM_GETTEXTLENGTH, 0, 0) > 0)
        ::SendMessageA(m_hOutWnd, EM_REPLACESEL, 0, (LPARAM)"\r\n");

    // write the type symbol
    if(bCmd)
        SendMessageA(m_hOutWnd, EM_REPLACESEL, 0 , (LPARAM)"> ");

    // write the text
    ::SendMessageA(m_hOutWnd, EM_REPLACESEL, 0, (LPARAM)pszText);
}
//---------------------------------------------------------------------------
void ConWinImpl_t::RegTxtRcvr(ConWin_t::TxtRcvr_i *pRcvr)
{
    FS_ASSERT(pRcvr);
    m_TxtRcvrs.push_back(pRcvr);
}
//---------------------------------------------------------------------------
void ConWinImpl_t::OnSize(int nW, int nH)
{
    // resize the output area
    FS_ASSERT(m_hOutWnd);
    ::SetWindowPos(m_hOutWnd, 0,
     0, 0, nW, nH - 20,
     SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE
    );
    
    // resize the command-line
    FS_ASSERT(m_hInWnd);
    ::SetWindowPos(
     m_hInWnd, 0,
     0, nH - 20, nW, 20,
     SWP_NOACTIVATE | SWP_NOZORDER
    );
}
//---------------------------------------------------------------------------
void ConWinImpl_t::OnReturn()
{
    FS_ASSERT(m_hInWnd);
    
    char szBuf[256];
    ::GetWindowTextA(m_hInWnd, szBuf, sizeof(szBuf) - 1);
    
    if(::strlen(szBuf) <= 0)
        return;
        
    // print the command
    Push(szBuf, true);
            
    // append the command into the history list
    while(m_Hist.size() > 50)
        m_Hist.erase(m_Hist.begin());
                
    m_Hist.push_back(szBuf);
    m_nHistPos = -1;
    
    ::SetWindowText(m_hInWnd, TEXT(""));
}
//---------------------------------------------------------------------------
void ConWinImpl_t::OnPrevCmd()
{
    int nHistCount = static_cast<int>(m_Hist.size());
    
    if(nHistCount <= 0)
        return;

    if(m_nHistPos == -1)
        m_nHistPos = nHistCount; // also compensates '--'
        
    m_nHistPos--;
    
    if(m_nHistPos < 0)
        m_nHistPos = 0;
     
    FS_ASSERT(m_hInWnd);
    ::SetWindowTextA(m_hInWnd, m_Hist[m_nHistPos].c_str());
    ::SendMessage(m_hInWnd, EM_SETSEL, 65535 , 65535);
}
//---------------------------------------------------------------------------
void ConWinImpl_t::OnNextCmd()
{
    int nHistCount = static_cast<int>(m_Hist.size());
    
    if(nHistCount <= 0)
        return;

    if(m_nHistPos == -1)
        m_nHistPos = nHistCount - 2; // also compensates '++'
        
    m_nHistPos++;
    
    if(m_nHistPos > nHistCount - 1)
     m_nHistPos = nHistCount - 1;
     
    FS_ASSERT(m_hInWnd);
    ::SetWindowTextA(m_hInWnd, m_Hist[m_nHistPos].c_str());
    ::SendMessage(m_hInWnd, EM_SETSEL, 65535 , 65535);
}
//---------------------------------------------------------------------------
bool ConWinImpl_t::IsInWin(HWND hWnd) const
{
    return hWnd == m_hInWnd;
}
//---------------------------------------------------------------------------
WNDPROC ConWinImpl_t::GetOrigInWndProc() const
{
    return m_pOrigInWndProc;
}
//---------------------------------------------------------------------------
HWND ConWinImpl_t::InitMainWin()
{
    HINSTANCE hInst = ::GetModuleHandle(0);
    FS_ASSERT(hInst);
    
    WNDCLASSEX wc;
    if(!::GetClassInfoEx(hInst, TEXT("FS_RAP_CONWIN"), &wc))
    {
        wc.cbSize = sizeof(WNDCLASSEX);
        wc.style = 0;
        wc.lpfnWndProc = WndProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 0;
        wc.hInstance = hInst;
        wc.hIcon = 0;
        wc.hCursor = 0;
        wc.hbrBackground = 0;
        wc.lpszMenuName = 0;
        wc.lpszClassName = TEXT("FS_RAP_CONWIN");
        wc.hIconSm = 0;
        
        if(!::RegisterClassEx(&wc))
        {
            FS_ASSERT_MSG(0, "Could not register the window class!");
            return 0;
        }
    }
        
    HWND hWnd = ::CreateWindowEx(
     0,
     TEXT("FS_RAP_CONWIN"),
     TEXT(""),
     WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME|WS_MAXIMIZEBOX,
     CW_USEDEFAULT, CW_USEDEFAULT,
     700, 450,
     0,
     0,
     hInst,
     0
    );
    
    return hWnd;
}
//---------------------------------------------------------------------------
HFONT ConWinImpl_t::InitOutFnt()
{
    HFONT hFnt = ::CreateFont(
     14,
     0,
     0,
     0,
     FW_NORMAL,
     FALSE,
     FALSE,
     FALSE,
     DEFAULT_CHARSET,
     OUT_CHARACTER_PRECIS,
     CLIP_CHARACTER_PRECIS,
     DEFAULT_QUALITY,
     DEFAULT_PITCH | FF_DONTCARE,
     TEXT("Courier")
    );
    
    return hFnt;
}
//---------------------------------------------------------------------------
HWND ConWinImpl_t::InitOutWin(HWND hParWnd)
{
    HINSTANCE hInst = ::GetModuleHandle(0);
    FS_ASSERT(hInst);

    HWND hWnd = ::CreateWindowEx(
     WS_EX_STATICEDGE,
     TEXT("EDIT"),
     TEXT(""),
     WS_CHILD | WS_VISIBLE | ES_MULTILINE | ES_READONLY | WS_VSCROLL,
     0, 0,
     0, 0,
     hParWnd,
     0,
     hInst,
     0
    );
    
    return hWnd;
}
//---------------------------------------------------------------------------
HWND ConWinImpl_t::InitInWin(HWND hParWnd)
{
    HINSTANCE hInst = ::GetModuleHandle(0);
    FS_ASSERT(hInst);

    HWND hWnd = ::CreateWindowEx(
     WS_EX_STATICEDGE,
     TEXT("EDIT"),
     TEXT(""),
     WS_CHILD | WS_VISIBLE | WS_VSCROLL,
     0, 0,
     0, 0,
     hParWnd,
     0,
     hInst,
     0
    );
            
    return hWnd;
}
//---------------------------------------------------------------------------
void ConWinImpl_t::Send(const char *pszText, bool bCmd)
{
    for(size_t i = 0, n = m_TxtRcvrs.size(); i < n; ++i)
    {
        m_TxtRcvrs[i]->Receive(pszText, bCmd);
    }
}
//---------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wPrm, LPARAM lPrm)
{
    switch(msg)
    {
        case WM_SIZE:
        {
            THwnd2ConMap::iterator it = g_Hwnd2ConMap.find(hWnd);
            ConWinImpl_t *pCW = it != g_Hwnd2ConMap.end() ? it->second : 0;
            FS_ASSERT(pCW);
            
            pCW->OnSize(LOWORD(lPrm), HIWORD(lPrm));
            
            break;
        }
        default:
            return DefWindowProc(hWnd, msg, wPrm, lPrm);
    }
    
    return 0;
}
//---------------------------------------------------------------------------
LRESULT CALLBACK InWndProc(HWND hWnd, UINT msg, WPARAM wPrm, LPARAM lPrm)
{
    // find the associated ConWinImpl_t object
    THwnd2ConMap::iterator it = g_Hwnd2ConMap.find(hWnd);
    ConWinImpl_t *pCW = it != g_Hwnd2ConMap.end() ? it->second : 0;
    FS_ASSERT(pCW);
    
    WNDPROC pOrigWndProc = pCW->GetOrigInWndProc();
    FS_ASSERT(pOrigWndProc);
    
    switch(msg)
    {
        case WM_KEYDOWN:
        {
            switch(wPrm)
            {
                case VK_RETURN: pCW->OnReturn(); break;
                case VK_UP: pCW->OnPrevCmd(); return 0;
                case VK_DOWN: pCW->OnNextCmd(); return 0;
            }
            break;
        }
    }
    
    return ::CallWindowProc(pOrigWndProc, hWnd, msg, wPrm, lPrm);
}
//---------------------------------------------------------------------------
} // anonymous namespace
//---------------------------------------------------------------------------
//--- CLASS ConWin_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
ConWin_t::ConWin_t(const char *pszTitle):
m_pImpl(new ConWinImpl_t(pszTitle))
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
}
//---------------------------------------------------------------------------
ConWin_t::~ConWin_t()
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    delete static_cast<ConWinImpl_t *>(m_pImpl);
}
//---------------------------------------------------------------------------
bool ConWin_t::IsValid() const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<ConWinImpl_t *>(m_pImpl)->IsValid();
}
//---------------------------------------------------------------------------
void ConWin_t::Show(bool bShow)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    static_cast<ConWinImpl_t *>(m_pImpl)->Show(bShow);
}
//---------------------------------------------------------------------------
void ConWin_t::SetPos(int nX, int nY, int nW, int nH)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    static_cast<ConWinImpl_t *>(m_pImpl)->SetPos(nX, nY, nW, nH);
}
//---------------------------------------------------------------------------
void ConWin_t::Push(const char *pszText)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    static_cast<ConWinImpl_t *>(m_pImpl)->Push(pszText);
}
//---------------------------------------------------------------------------
void ConWin_t::RegTxtRcvr(TxtRcvr_i *pRcvr)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    static_cast<ConWinImpl_t *>(m_pImpl)->RegTxtRcvr(pRcvr);
}
//---------------------------------------------------------------------------

---

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