TnbMfcTinyListDialog.h

[詳解]

#pragma once
#include "TnbMfcColorListBox.h"
#include "TnbMfcLightListBox.h"
#include "TnbMfcDelayedRedraw.h"
#include "TnbDummyWindow.h"
#include "TnbConstStrVector.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CTinyListDialog : private CDummyWindow::IListener
{
public:
 
    enum EMenuId
    {
        MenuId_Hide = 1000,     
        MenuId_Clear = 1001,    
    };
 
    enum EShowMode
    {
        SHOW,       
        HIDE,       
        TOGGLE,     
    };
 
    enum EMoveMode
    {
        CENTER,     
        UNDER,      
        RIGHT,      
    };
 
    CTinyListDialog(bool isColorMode = true) : m_hParentWnd(NULL), m_parentMenuItem(0), m_isColorMode(isColorMode)
    {
        if ( isColorMode )
        {
            m_pListBox = &m_logColorList;
        }
        else
        {
            m_pListBox = &m_logBwList;
        }
    }
 
    bool Create(const CSize& size, HFONT hFont, HWND hParentWnd, LPCTSTR lpszTitle, HICON hIcon, UINT parentMenuItem = 0)
    {
        // メニュー
        if ( m_menu.GetSafeHmenu() == NULL )
        {
            m_subMenu1.CreateMenu();
            m_subMenu2.CreateMenu();
            m_menu.CreateMenu();
            m_subMenu1.AppendMenu(0, MenuId_Hide, _T("隠す(&H)"));
            m_subMenu2.AppendMenu(0, MenuId_Clear, _T("クリア(&C)"));
            m_menu.AppendMenu(MF_POPUP, reinterpret_cast<UINT_PTR>(m_subMenu1.GetSafeHmenu()), _T("ファイル(&F)"));
            m_menu.AppendMenu(MF_POPUP, reinterpret_cast<UINT_PTR>(m_subMenu2.GetSafeHmenu()), _T("表示(&H)"));
        }
        if ( ! m_dmyWnd.Create(this, lpszTitle, NULL, (WS_OVERLAPPEDWINDOW & ~WS_MINIMIZEBOX) | WS_CLIPCHILDREN, m_menu) )
        {
            return false;
        }
        m_parentMenuItem = parentMenuItem;
        m_hParentWnd = hParentWnd;
        CWnd* pDmyWnd = CWnd::FromHandle(m_dmyWnd);
        ::SetWindowPos(m_dmyWnd, hParentWnd, 0, 0, size.cx, size.cy, 0);
        pDmyWnd->CenterWindow();
        CRect rc(0, 0, size.cx, size.cy);
        DWORD style = LBS_NOINTEGRALHEIGHT | LBS_EXTENDEDSEL | WS_VSCROLL;
        if ( m_isColorMode )
        {
            style |= LBS_OWNERDRAWVARIABLE;;
            style |= LBS_HASSTRINGS;
        }
        else
        {
            style |= LBS_OWNERDRAWFIXED | LBS_NODATA;
        }
        m_pListBox->Create(style, rc, pDmyWnd, 1000);
        m_pListBox->SetFont(CFont::FromHandle(hFont));
        m_pListBox->ShowWindow(SW_SHOW);
        m_pListBox->ModifyStyleEx(0, WS_EX_CLIENTEDGE, SWP_FRAMECHANGED);
        pDmyWnd->SendMessage(WM_SETICON, 0, reinterpret_cast<LPARAM>(hIcon));
        pDmyWnd->Detach();
        OnCreate();
        return true;
    }
 
    bool Create(const CSize& size, HWND hParentWnd, LPCTSTR lpszTitle, HICON hIcon, UINT parentMenuItem = 0)
    {
        HFONT hFont = reinterpret_cast<HFONT>(::SendMessage(hParentWnd, WM_GETFONT, 0, 0));
        return Create(size, hFont, hParentWnd, lpszTitle, hIcon, parentMenuItem);
    }
 
    void MoveWindow(EMoveMode mode = UNDER)
    {
        if ( m_dmyWnd != NULL )
        {
            CRect rc;
            ::GetWindowRect(m_hParentWnd, &rc);
            switch ( mode )
            {
            case CENTER:// 中央
                {
                    CWnd* pDmyWnd = CWnd::FromHandle(m_dmyWnd);
                    pDmyWnd->CenterWindow();
                    pDmyWnd->Detach();
                }
                break;
            case UNDER:// 下
                ::SetWindowPos(m_dmyWnd, NULL, rc.left, rc.bottom, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
                break;
            case RIGHT:// 右
                ::SetWindowPos(m_dmyWnd, NULL, rc.right, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
                break;
            }
        }
    }
 
    void Destroy(void)
    {
        m_dmyWnd.Destroy();
    }
 
    operator HWND(void)
    {
        return m_dmyWnd;
    }
 
    bool IsWindow(void) const
    {
        return m_dmyWnd.IsWindow();
    }
 
    bool IsWindowVisible(void)
    {
        return !! ::IsWindowVisible(m_dmyWnd);
    }
 
    void ShowWindow(EShowMode mode = SHOW)
    {
        int m = (mode == SHOW) ? SW_SHOW : SW_HIDE;
        if ( mode == TOGGLE )
        {
            m = IsWindowVisible() ? SW_HIDE : SW_SHOW;
        }
        ::ShowWindow(m_dmyWnd, m);
    }
 
    void SetTopMost(bool isTop = true)
    {
        ::SetWindowPos(m_dmyWnd, isTop ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
    }
 
    CColorListBox& ReferColorList(void)
    {
        ASSERT( m_isColorMode );
        return m_logColorList;
    }
 
    CLightListBox& ReferBwList(void)
    {
        ASSERT( ! m_isColorMode );
        return m_logBwList;
    }
 
    CMenu& ReferMenu(void)
    {
        return m_menu;
    }
 
    void SetCurrentColor(COLORREF colorText, COLORREF colorBack)
    {
        ASSERT( m_isColorMode );
        m_logColorList.SetCurrentColor(colorText, colorBack);
    }
 
    void SetColor(int nIndex, COLORREF colorText, COLORREF colorBack)
    {
        ASSERT( m_isColorMode );
        m_logColorList.SetColor(nIndex, colorText, colorBack);
    }
 
    void SetMargin(DWORD m)
    {
        m_logColorList.SetMargin(m);
        m_logBwList.SetMargin(m);
    }
 
    void SetMaxLine(int maxLine)
    {
        m_logColorList.SetMaxLine(maxLine);
        m_logBwList.SetMaxLine(maxLine);
    }
 
    void SetFont(CFont* pFont)
    {
        m_pListBox->SetFont(pFont);
    }
 
    void SetPostViewMode(bool isView)
    {
        ASSERT( m_isColorMode );
        m_logColorList.SetPostViewMode(isView);
    }
 
    void PostString(int nIndex, LPCTSTR lpszItem, COLORREF colorText = 0, COLORREF colorBack = 0)
    {
        if ( m_isColorMode )
        {
            m_logColorList.PostString(nIndex, lpszItem, colorText, colorBack);
        }
        else
        {
            m_logBwList.PostString(nIndex, lpszItem);
        }
        if ( m_parentMenuItem == 0 )
        {
            ShowWindow();
        }
    }
 
    void PostString(LPCTSTR lpszItem, COLORREF colorText = 0, COLORREF colorBack = 0)
    {
        PostString(-1, lpszItem, colorText, colorBack);
    }
 
    void PostStringCr(LPCTSTR lpszItem, COLORREF colorText = 0, COLORREF colorBack = 0)
    {
        CConstStrVector vs;
        vs.SetClone(lpszItem);
        loop ( i, vs.GetLineCount() )
        {
            PostString(-1, vs.GetString(i), colorText, colorBack);
        }
    }
 
protected:
 
    virtual void OnCreate(void)
    {
    }
 
    virtual void OnDestroy(void)
    {
    }
 
    virtual void OnCommand(WPARAM wParam)
    {
        switch ( wParam )
        {
        case MenuId_Hide://隠す
            ::ShowWindow(*this, SW_HIDE);
            break;
        case MenuId_Clear://クリア
            m_pListBox->ResetContent();
            break;
        }
    }
 
private:
    virtual bool OnWindowMessage(LRESULT& _result, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_CLOSE:
            ::ShowWindow(m_dmyWnd, SW_HIDE);
            return true;
        case WM_MEASUREITEM:
            m_pListBox->MeasureItem(reinterpret_cast<LPMEASUREITEMSTRUCT>(lParam));
            break;
        case WM_DRAWITEM:
            m_pListBox->DrawItem(reinterpret_cast<LPDRAWITEMSTRUCT>(lParam));
            break;
        case WM_SIZE:
            if ( ::IsWindow(m_pListBox->GetSafeHwnd()) )
            {
                CSize sz(LOWORD(lParam), HIWORD(lParam));
                m_pListBox->SetWindowPos(NULL, 0, 0, sz.cx, sz.cy, SWP_NOZORDER);
            }
            break;
        case WM_KEYUP:
        case WM_KEYDOWN:
        case WM_CHAR:
            m_pListBox->SendMessage(message, wParam, lParam);
            break;
        case WM_DESTROY:
            m_menu.DestroyMenu();
            OnDestroy();
            break;
        case WM_SHOWWINDOW:
            if ( m_parentMenuItem != 0 )
            {
                HMENU h = ::GetMenu(m_hParentWnd);
                if ( h != NULL )
                {
                    UINT r = (wParam != 0) ? MF_CHECKED : MF_UNCHECKED;
                    ::CheckMenuItem(h, m_parentMenuItem, r);
                }
            }
            break;
        case WM_COMMAND:
            OnCommand(wParam);
            break;
        default:
            break;
        }
        return false;
    }
    class CInListBox : public CDelayedRedrawAddinT<CColorListBox>
    {
        DEFSUPER(CDelayedRedrawAddinT<CColorListBox>);
    protected:
        virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
        {
            if ( message == WM_CLB_POSTSTRING )
            {
                _super::DelayedRedraw();
            }
            return _super::WindowProc(message, wParam, lParam);
        }
    };
 
    HWND            m_hParentWnd;       
    CListBox*       m_pListBox;         
    CInListBox      m_logColorList;     
    CLightListBox   m_logBwList;        
    CDummyWindow    m_dmyWnd;           
    CMenu           m_menu;             
    CMenu           m_subMenu1;         
    CMenu           m_subMenu2;         
    UINT            m_parentMenuItem;   
    bool            m_isColorMode;      
};
 
 
 
}; // MFC
}; // TNB