EvMessageMap.h

[詳解]

//  $Revision: 1.1 $
/*
    @file   EvMessageMap.h
    @brief  CEvMessageMap class header
    @author FAST Corporation
*/

#ifndef _EVMESSAGEMAP_H_INCLUDED_
#define _EVMESSAGEMAP_H_INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

// ///////////////////////////////////////////////////////////////////////////
// INCLUDE
#include "FvObject.h"
#include "MultiData/FvList.h"

// ///////////////////////////////////////////////////////////////////////////
// CLASS 
#pragma pack(push,_FVCL_PACKING)

template<class TYPE> class CEvMessageMap : public FVCL::CFvObject
{
public:
    // TYPEDEF
    typedef void (*LPCOMMANDHANDLER)( void*, TYPE*, WPARAM, LPARAM );
    typedef void (*LPWNDMSGHANDLER)( void*, TYPE*, UINT, WPARAM, LPARAM );

public:
// ///////////////////////////////////////////////////////////////////////////
// CONSTRUCTOR/DESTRUCTOR

// =================================================================
CEvMessageMap()
{
    m_OnCommandPre  = NULL;
    m_OnCommandPost = NULL;
    m_OnWndMsgPre   = NULL;
    m_OnWndMsgPost  = NULL;

    m_pvCommandPre  = NULL;
    m_pvCommandPost = NULL;
    m_pvWndMsgPre   = NULL;
    m_pvWndMsgPost  = NULL;

    m_blCommandPre  = true;
    m_blCommandPost = true;
    m_blWndMsgPre   = true;
    m_blWndMsgPost  = true;
}

// =================================================================
~CEvMessageMap()
{
}

// METHOD

// =================================================================
bool SetCommandPre( LPCOMMANDHANDLER function, void* owner )
{
    m_OnCommandPre = function;
    m_pvCommandPre = owner;
    return true;
}

// =================================================================
bool GetCommandPre( LPCOMMANDHANDLER* function, void** owner ) const
{
    if( function )  *function = m_OnCommandPre;
    if( owner )     *owner    = m_pvCommandPre;
    return true;
}

// =================================================================
bool SetCommandPost( LPCOMMANDHANDLER function, void* owner )
{
    m_OnCommandPost = function;
    m_pvCommandPost = owner;
    return true;
}

// =================================================================
bool GetCommandPost( LPCOMMANDHANDLER* function, void** owner ) const
{
    if( function )  *function = m_OnCommandPost;
    if( owner )     *owner    = m_pvCommandPost;
    return true;
}


// =================================================================
bool SetWndMsgPre( LPWNDMSGHANDLER function, void* owner )
{
    m_OnWndMsgPre = function;
    m_pvWndMsgPre = owner;
    return true;
}

// =================================================================
bool GetWndMsgPre( LPWNDMSGHANDLER* function, void** owner ) const
{
    if( function )  *function = m_OnWndMsgPre;
    if( owner )     *owner    = m_pvWndMsgPre;
    return true;
}


// =================================================================
bool SetWndMsgPost( LPWNDMSGHANDLER function, void* owner )
{
    m_OnWndMsgPost = function;
    m_pvWndMsgPost = owner;
    return true;
}

// =================================================================
bool GetWndMsgPost( LPWNDMSGHANDLER* function, void** owner ) const
{
    if( function )  *function = m_OnWndMsgPost;
    if( owner )     *owner    = m_pvWndMsgPost;
    return true;
}

// =================================================================
bool AddDialog( TYPE* dlg, UINT filter=FVCL::DlgCtrlFilter::NONE )
{
    if( dlg == NULL ) return false;

    for( UINT i=0 ; i<m_dialogs.size() ; i++ )
    {
        if( m_dialogs[i] == dlg )
            return false;
    }

    m_dialogs.push_back( dlg );
    if( filter != FVCL::DlgCtrlFilter::NONE )
        m_filters.push_back( filter );
    else
        m_filters.push_back( dlg->GetDlgCtrlFilter() );

    dlg->AddMessageMap( this );

    return true;
}

// =================================================================
bool DelDialog( const TYPE* dlg )
{
    if( dlg == NULL ) return false;

    for( UINT i=0 ; i<m_dialogs.size() ; i++ )
    {
        if( m_dialogs[i] == dlg )
        {
            m_dialogs[i]->DelMessageMap( this );

            FVCL::CFvList<TYPE*>::iterator      iter1 = m_dialogs.begin();
            FVCL::CFvList<UINT>::iterator       iter2 = m_filters.begin();
            iter1 += (INT)i;
            iter2 += (INT)i;
            m_dialogs.erase( iter1 );
            m_filters.erase( iter2 );
            return true;
        }
    }
    return false;
}

// =================================================================
UINT GetDialogCount( UINT fixedID=0, UINT filter=FVCL::DlgCtrlFilter::NONE ) const
{
    if( fixedID == 0 && filter == FVCL::DlgCtrlFilter::NONE )
        return m_dialogs.size();

    INT     count = 0;
    for( UINT i=0 ; i<m_dialogs.size() ; i++ )
    {
        TYPE*   dlg = m_dialogs[i];
        UINT        flt = m_filters[i];

        if( fixedID != 0 && fixedID != dlg->GetDlgCtrlFixedID() )
            continue;
        if( filter != FVCL::DlgCtrlFilter::NONE && !(filter & flt) )
            continue;
    
        count++;
    }
    return count;
}

// =================================================================
TYPE* GetDialog( UINT index ) const
{
    return m_dialogs[index];
}

// =================================================================
TYPE* GetDialogByFixedID( UINT fixedID=0, UINT filter=FVCL::DlgCtrlFilter::NONE ) const
{
    for( UINT i=0 ; i<m_dialogs.size() ; i++ )
    {
        TYPE*   dlg = m_dialogs[i];
        UINT    flt = m_filters[i];

        if( fixedID != 0 && fixedID != dlg->GetDlgCtrlFixedID() )
            continue;
        if( filter != FVCL::DlgCtrlFilter::NONE && !(filter & flt) )
            continue;
    
        return dlg;
    }
    return NULL;
}

// =================================================================
bool SetDialogFilter( UINT index, UINT filter )
{
    if( m_filters.size() <= index ) return false;
    m_filters[index] = filter;
    return true;
}

// =================================================================
UINT GetDialogFilter( UINT index ) const
{
    return m_filters[index];
}

// =================================================================
UINT UpdateDialog( bool bReDraw=true, UINT fixedID=0, UINT filter=FVCL::DlgCtrlFilter::NONE )
{
    INT     count = 0;
    for( UINT i=0 ; i<m_dialogs.size() ; i++ )
    {
        TYPE*   dlg = m_dialogs[i];
        UINT        flt = m_filters[i];

        if( fixedID != 0 && fixedID != dlg->GetDlgCtrlFixedID() )
            continue;
        if( filter != FVCL::DlgCtrlFilter::NONE && !(filter & flt) )
            continue;
    
        if( dlg->Update( bReDraw ) )
            count++;
    }
    return count;
}

// EVENT HANDLER

// =================================================================
static void ICommandPre( void* pvParam, TYPE* dlg, WPARAM wParam, LPARAM lParam )
{
    CEvMessageMap*      pThis = static_cast<CEvMessageMap*>(pvParam);
    if( !pThis->m_blCommandPre ) return;

    LPCOMMANDHANDLER    function = pThis->m_OnCommandPre;
    void*               owner    = pThis->m_pvCommandPre;

    if( function )
        function( owner, dlg, wParam, lParam );
    else
        pThis->OnCommandPre( dlg, wParam, lParam );
}

// =================================================================
static void ICommandPost( void* pvParam, TYPE* dlg, WPARAM wParam, LPARAM lParam )
{
    CEvMessageMap*      pThis = static_cast<CEvMessageMap*>(pvParam);
    if( !pThis->m_blCommandPost ) return;

    LPCOMMANDHANDLER    function = pThis->m_OnCommandPost;
    void*               owner    = pThis->m_pvCommandPost;

    if( function )
        function( owner, dlg, wParam, lParam );
    else
        pThis->OnCommandPost( dlg, wParam, lParam );
}

// =================================================================
static void IWndMsgPre( void* pvParam, TYPE* dlg, UINT message, WPARAM wParam, LPARAM lParam )
{
    CEvMessageMap*      pThis = static_cast<CEvMessageMap*>(pvParam);
    if( !pThis->m_blWndMsgPre ) return;

    LPWNDMSGHANDLER     function = pThis->m_OnWndMsgPre;
    void*               owner    = pThis->m_pvWndMsgPre;

    if( function )
        function( owner, dlg, message, wParam, lParam );
    else
        pThis->OnWndMsgPre( dlg, message, wParam, lParam );
}

// =================================================================
static void IWndMsgPost( void* pvParam, TYPE* dlg, UINT message, WPARAM wParam, LPARAM lParam )
{
    CEvMessageMap*      pThis = static_cast<CEvMessageMap*>(pvParam);
    if( !pThis->m_blWndMsgPost ) return;

    LPWNDMSGHANDLER     function = pThis->m_OnWndMsgPost;
    void*               owner    = pThis->m_pvWndMsgPost;

    if( function )
        function( owner, dlg, message, wParam, lParam );
    else
        pThis->OnWndMsgPost( dlg, message, wParam, lParam );
}

protected:
// PROTECTED FUNCTION

// =================================================================
virtual void OnCommandPre( TYPE* dlg, WPARAM wParam, LPARAM lParam )
{
}

// =================================================================
virtual void OnCommandPost( TYPE* dlg, WPARAM wParam, LPARAM lParam )
{
}

// =================================================================
virtual void OnWndMsgPre( TYPE* dlg, UINT message, WPARAM wParam, LPARAM lParam )
{
}

// =================================================================
virtual void OnWndMsgPost( TYPE* dlg, UINT message, WPARAM wParam, LPARAM lParam )
{
}

public:
    // OBJECT
    bool                    m_blCommandPre;
    bool                    m_blCommandPost;
    bool                    m_blWndMsgPre;
    bool                    m_blWndMsgPost;

protected:
    // OBJECT
    FVCL::CFvList<TYPE*>    m_dialogs;
    FVCL::CFvList<UINT>     m_filters;

    LPCOMMANDHANDLER        m_OnCommandPre;
    LPCOMMANDHANDLER        m_OnCommandPost;
    LPWNDMSGHANDLER         m_OnWndMsgPre;
    LPWNDMSGHANDLER         m_OnWndMsgPost;

    void*                   m_pvCommandPre;
    void*                   m_pvCommandPost;
    void*                   m_pvWndMsgPre;
    void*                   m_pvWndMsgPost;
};

#pragma pack(pop)

#endif // _EVMESSAGEMAP_H_INCLUDED_