D:/Zythum/DinoKod/Viewer/childfrm.cpp

// ChildFrm.cpp : implémentation de la classe CChildFrame
//
#include "stdafx.h"
#include "Viewer.h"

#include "ChildFrm.h"
#include "LeftView.h"
#include "TreeAnimView.h"
#include "BottomView.h"
#include "ViewerDoc.h"
#include "ViewerView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CChildFrame

IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWnd)

BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWnd)
//      ON_UPDATE_COMMAND_UI_RANGE(AFX_ID_VIEW_MINIMUM, AFX_ID_VIEW_MAXIMUM, OnUpdateViewStyles)
//      ON_COMMAND_RANGE(AFX_ID_VIEW_MINIMUM, AFX_ID_VIEW_MAXIMUM, OnViewStyle)
ON_WM_CREATE()
ON_WM_DESTROY()
ON_COMMAND(ID_DISPLAY_SHOWSELECTION, OnDisplayShowselection)
ON_WM_SIZE()
ON_WM_SIZING()
END_MESSAGE_MAP()


// construction ou destruction de CChildFrame

CChildFrame::CChildFrame()
{
        m_pGameViewer           = NULL;
        m_pDocument                     = NULL;
        m_bAutoMenuEnable       = FALSE;
}

CChildFrame::~CChildFrame()
{
        if( m_pGameViewer )
                Deletep( m_pGameViewer );
}

BOOL CChildFrame::OnCreateClient(LPCREATESTRUCT /*lpcs*/, CCreateContext* pContext)
{
        m_pDocument = (CViewerDoc*)pContext->m_pCurrentDoc;

        // Splitter vertical au centre
        if (!m_wndSplitter.CreateStatic(this, 1, 2))
                return FALSE;

        // Splitter horizontal a gauche
        if (!m_wndSplitter2.CreateStatic( &m_wndSplitter, 2, 1, WS_CHILD | WS_VISIBLE, m_wndSplitter.IdFromRowCol(0, 0)))
                return FALSE;

        if (!m_wndSplitter2.CreateView(0, 0, RUNTIME_CLASS(CLeftView), CSize(0, 100), pContext) ||
                !m_wndSplitter2.CreateView(1, 0, RUNTIME_CLASS(CTreeAnimView), CSize(100, 0), pContext))
        {
                m_wndSplitter.DestroyWindow();
                m_wndSplitter2.DestroyWindow();
                return FALSE;
        }

        // Splitter horizontal a droite
        if (!m_wndSplitter3.CreateStatic( &m_wndSplitter, 2, 1, /*WS_DISABLED | */WS_CHILD | WS_VISIBLE, m_wndSplitter.IdFromRowCol(0, 1)))
                return FALSE;

        if (!m_wndSplitter3.CreateView(0, 0, RUNTIME_CLASS(CViewerView), CSize(100, 250), pContext) ||
                !m_wndSplitter3.CreateView(1, 0, RUNTIME_CLASS(CBottomView), CSize(100, 150), pContext))
        {
                m_wndSplitter.DestroyWindow();
                m_wndSplitter2.DestroyWindow();
                m_wndSplitter3.DestroyWindow();
                return FALSE;
        }

        CRect Rect;
        GetWindowRect( &Rect );

        m_wndSplitter.SetColumnInfo( 0, 200, 10 );
        m_wndSplitter2.SetRowInfo( 0, 300, 10 );
        m_wndSplitter3.SetRowInfo( 0, 250, 100 );
        m_wndSplitter3.SetRowInfo( 1, 150, 100 );

        // Menu
        m_Menu.LoadMenu( IDR_MENU_CHILD );
        SetHandles( m_Menu.GetSafeHmenu(), NULL );
        DrawMenuBar();

        CMenu*  pMenu = m_Menu.GetSubMenu( 2 );
        pMenu->CheckMenuItem( ID_DISPLAY_SHOWSELECTION, MF_BYCOMMAND | MF_UNCHECKED );

        return TRUE;
}

BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs)
{
        // TODO : Changez ici la classe ou les styles Window en modifiant CREATESTRUCT cs
        if( !CMDIChildWnd::PreCreateWindow(cs) )
                return FALSE;

        return TRUE;
}


// diagnostics pour CChildFrame

#ifdef _DEBUG
void CChildFrame::AssertValid() const
{
        CMDIChildWnd::AssertValid();
}

void CChildFrame::Dump(CDumpContext& dc) const
{
        CMDIChildWnd::Dump(dc);
}

#endif //_DEBUG


// gestionnaires de messages pour CChildFrame
/*CTestMDIView* CChildFrame::GetRightPane()
{
        CWnd* pWnd = m_wndSplitter.GetPane(0, 1);
        CTestMDIView* pView = DYNAMIC_DOWNCAST(CTestMDIView, pWnd);
        return pView;
}
*//*
void CChildFrame::OnUpdateViewStyles(CCmdUI* pCmdUI)
{
        // TODO : personnalisez ou étendez ce code en vue de la gestion des options dans le menu Affichage.
        CTestMDIView* pView = GetRightPane(); 

        // si le volet de droite n'a pas été créé ou n'est pas une vue, désactiver les commandes dans notre étendue
        if (pView == NULL)
                pCmdUI->Enable(FALSE);
        else
        {
                DWORD dwStyle = pView->GetStyle() & LVS_TYPEMASK;
                // si la commande est ID_VIEW_LINEUP, activer la commande
                // uniquement en mode LVS_ICON ou LVS_SMALLICON
                if (pCmdUI->m_nID == ID_VIEW_LINEUP)
                {
                        if (dwStyle == LVS_ICON || dwStyle == LVS_SMALLICON)
                                pCmdUI->Enable();
                        else
                                pCmdUI->Enable(FALSE);
                }
                else
                {
                        // sinon, utiliser des pointillés pour refléter le style de la vue
                        pCmdUI->Enable();
                        BOOL bChecked = FALSE;

                        switch (pCmdUI->m_nID)
                        {
                        case ID_VIEW_DETAILS:
                                bChecked = (dwStyle == LVS_REPORT);
                                break;

                        case ID_VIEW_SMALLICON:
                                bChecked = (dwStyle == LVS_SMALLICON);
                                break;

                        case ID_VIEW_LARGEICON:
                                bChecked = (dwStyle == LVS_ICON);
                                break;

                        case ID_VIEW_LIST:
                                bChecked = (dwStyle == LVS_LIST);
                                break;

                        default:
                                bChecked = FALSE;
                                break;
                        }

                        pCmdUI->SetRadio(bChecked ? 1 : 0);
                }
        }
}
*//*
void CChildFrame::OnViewStyle(UINT nCommandID)
{
        // TODO : personnalisez ou étendez ce code en vue de la gestion des options dans le menu Affichage.
        CTestMDIView* pView = GetRightPane();

        // si le volet de droite a été créé et qu'il s'agit d'une vue CTestMDIView, les commandes de menu sont exécutées...
        if (pView != NULL)
        {
                int nStyle = -1;

                switch (nCommandID)
                {
                case ID_VIEW_LINEUP:
                        {
                                // demander au contrôle List de s'aligner sur la grille
                                CListCtrl& refListCtrl = pView->GetListCtrl();
                                refListCtrl.Arrange(LVA_SNAPTOGRID);
                        }
                        break;

                // d'autres commandes changent le style du contrôle List
                case ID_VIEW_DETAILS:
                        nStyle = LVS_REPORT;
                        break;

                case ID_VIEW_SMALLICON:
                        nStyle = LVS_SMALLICON;
                        break;

                case ID_VIEW_LARGEICON:
                        nStyle = LVS_ICON;
                        break;

                case ID_VIEW_LIST:
                        nStyle = LVS_LIST;
                        break;
                }

                // changer le style et repeindre automatiquement la fenêtre
                if (nStyle != -1)
                        pView->ModifyStyle(LVS_TYPEMASK, nStyle);
        }
}
*/
int CChildFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
        theApp.ResetCurrentDirectory();

        if (CMDIChildWnd::OnCreate(lpCreateStruct) == -1)
                return -1;

        CViewerView* pView = GetDocument()->GetViewerView();

        CRect   cRect = pView->GetViewerRect();
        KRect   kRect( cRect.left, cRect.top, cRect.right, cRect.bottom );
        m_pGameViewer = new KGameViewer( theApp.m_hInstance );
        if( !m_pGameViewer->Init( pView->m_hWnd, kRect ) )
                return -1;

        GetDocument()->SetChildFrame( this );

        return 0;
}

void CChildFrame::OnDestroy()
{
        CMDIChildWnd::OnDestroy();

        if( m_pGameViewer )
        {
                m_pGameViewer->End();
                if( m_pGameViewer )
                        Deletep( m_pGameViewer );
        }
}

bool CChildFrame::Manage()
{
        if( m_pGameViewer )
                m_pGameViewer->Run();

        return true;
}

BOOL CChildFrame::OnCommand(WPARAM wParam, LPARAM lParam)
{
        // TODO : ajoutez ici votre code spécialisé et/ou l'appel de la classe de base

        return CMDIChildWnd::OnCommand(wParam, lParam);
}

void CChildFrame::OnDisplayShowselection()
{
        // TODO : ajoutez ici le code de votre gestionnaire de commande
        CMenu*  pMenu = m_Menu.GetSubMenu( 2 );
        UINT    State = pMenu->GetMenuState( ID_DISPLAY_SHOWSELECTION, MF_BYCOMMAND );
        
        if( State & MF_CHECKED )
        {
                pMenu->CheckMenuItem( ID_DISPLAY_SHOWSELECTION, MF_BYCOMMAND | MF_UNCHECKED );
                GetDocument()->GetBottomView()->SetShowSelection( false );
                GetDocument()->GetBottomView()->Refresh();
        }
        else
        {
                pMenu->CheckMenuItem( ID_DISPLAY_SHOWSELECTION, MF_BYCOMMAND | MF_CHECKED );
                GetDocument()->GetBottomView()->SetShowSelection( true );
                GetDocument()->GetBottomView()->Refresh();
        }
}

void CChildFrame::OnSize(UINT nType, int cx, int cy)
{
        CMDIChildWnd::OnSize(nType, cx, cy);

//      if( m_wndSplitter3.GetSafeHwnd() )
//              m_wndSplitter3.SplitRow( cy - 100 );

}

void CChildFrame::OnSizing(UINT fwSide, LPRECT pRect)
{
        CMDIChildWnd::OnSizing(fwSide, pRect);

//      m_wndSplitter3.SetRowInfo( 0, ( pRect->bottom - pRect->top ) - 100, 0 );

//      m_wndSplitter3.m.MoveWindow( pRect, TRUE ); 
/*      if( m_wndSplitter3.GetSafeHwnd() )
                m_wndSplitter3.*/
}

---