satellite/neuromanager/MainFrm.cpp

/* --------------------------------------------------------------------- */
/* NeuroManager - A spike train analysis tool                            */
/* Copyright (c) 2005-2006 RIKEN, Japan. All rights reserved.            */
/* http://satellite.sourceforge.jp/                                      */
/* --------------------------------------------------------------------- */
/* This program is free software; you can redistribute it and/or         */
/* modify it under the terms of the GNU General Public License           */
/* as published by the Free Software Foundation; either version 2        */
/* of the License, or (at your option) any later version.                */
/*                                                                       */
/* This program is distributed in the hope that it will be useful,       */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of        */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         */
/* GNU General Public License for more details.                          */
/*                                                                       */
/* You should have received a copy of the GNU General Public License     */
/* along with this program; see the file COPYING.txt. If not, write      */
/* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth      */
/* Floor, Boston, MA 02110-1301, USA.                                    */
/* --------------------------------------------------------------------- */

/* $Id: MainFrm.cpp,v 1.14 2006/02/02 07:33:27 orrisroot Exp $ */

// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "NeuroManager.h"
#include "DataViewSplitter.h"
#include "DataViewBar.h"
#include "SpikeViewSplitter.h"
#include "SpikeViewBar.h"

#include "MainFrm.h"
#include ".\mainfrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CMainFrame

IMPLEMENT_DYNCREATE( CMainFrame, CFrameWnd )

BEGIN_MESSAGE_MAP( CMainFrame, CFrameWnd )
ON_WM_CREATE()
ON_COMMAND( ID_VIEW_DATAVIEW_BAR, OnViewDataViewBar )
ON_COMMAND( ID_VIEW_SPIKEVIEW_BAR, OnViewSpikeViewBar )
ON_UPDATE_COMMAND_UI( ID_VIEW_DATAVIEW_BAR, OnUpdateViewDataViewBar )
ON_UPDATE_COMMAND_UI( ID_VIEW_SPIKEVIEW_BAR, OnUpdateViewSpikeViewBar )
END_MESSAGE_MAP()

static UINT indicators[] =
    {
        // status line indicator
        ID_SEPARATOR,
        ID_INDICATOR_CAPS,
        ID_INDICATOR_NUM,
        ID_INDICATOR_SCRL,
    };


// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
        // TODO: add member initialization code here
}

CMainFrame::~CMainFrame()
{}


int CMainFrame::OnCreate( LPCREATESTRUCT lpCreateStruct )
{
        if ( CFrameWnd::OnCreate( lpCreateStruct ) == -1 )
                return -1;

        if ( !m_wndToolBar.CreateEx( this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
                                     | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC ) ||
                !m_wndToolBar.LoadToolBar( IDR_MAINFRAME ) )
        {
                TRACE0( "Failed to create toolbar\n" );
                return -1; // fail to create
        }

        if ( !m_wndStatusBar.Create( this ) ||
                !m_wndStatusBar.SetIndicators( indicators,
                                               sizeof( indicators ) / sizeof( UINT ) ) )
        {
                TRACE0( "Failed to create status bar\n" );
                return -1; // fail to create
        }

        // data view bar
        CString strDataView;
        strDataView.LoadString( IDS_DATAVIEW );
        if ( !m_wndDataViewBar.Create( strDataView, this,
                                       CSize( DEFAULT_DATAVIEW_WIDTH, DEFAULT_DATAVIEW_HEIGHT ), TRUE, IDS_DATAVIEW ) )
        {
                TRACE0( "Failed to create data view bar\n" );
                return -1; // fail to create
        }
        CCreateContext* pContext = ( CCreateContext* ) lpCreateStruct->lpCreateParams;
        BOOL ret = m_wndDataViewBar.CreateInnerViews( pContext );
        if ( ret == FALSE )
                return -1;

        m_wndDataViewBar.SetBarStyle( m_wndDataViewBar.GetBarStyle() |
                                      CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC );

        // spike view bar
        CString strSpikeView;
        strSpikeView.LoadString( IDS_SPIKEVIEW );
        if ( !m_wndSpikeViewBar.Create( strSpikeView, this,
                                       CSize( DEFAULT_DATAVIEW_WIDTH, DEFAULT_DATAVIEW_HEIGHT ), TRUE, IDS_SPIKEVIEW ) )
        {
                TRACE0( "Failed to create spike view bar\n" );
                return -1; // fail to create
        }
        pContext = ( CCreateContext* ) lpCreateStruct->lpCreateParams;
        ret = m_wndSpikeViewBar.CreateInnerViews( pContext );
        if ( ret == FALSE )
                return -1;

        m_wndSpikeViewBar.SetBarStyle( m_wndSpikeViewBar.GetBarStyle() |
                                      CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC );

        // setting for dockable bars
        m_wndToolBar.EnableDocking( CBRS_ALIGN_ANY );
        m_wndDataViewBar.EnableDocking( CBRS_ALIGN_TOP );
        m_wndSpikeViewBar.EnableDocking( CBRS_ALIGN_ANY );
        EnableDocking( CBRS_ALIGN_ANY );
        DockControlBar( &m_wndToolBar );
        DockControlBar( &m_wndDataViewBar );
        DockControlBar( &m_wndSpikeViewBar );

        // load scrollbar setting
        SaveLoadToolBar( FALSE );

        return 0;
}

BOOL CMainFrame::PreCreateWindow( CREATESTRUCT& cs )
{
        if ( !CFrameWnd::PreCreateWindow( cs ) )
                return FALSE;
        // TODO: Modify the Window class or styles here by modifying
        //  the CREATESTRUCT cs
        cs.style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
        return TRUE;
}


// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
        CFrameWnd::AssertValid();
}

void CMainFrame::Dump( CDumpContext& dc ) const
{
        CFrameWnd::Dump( dc );
}
#endif //_DEBUG


// CMainFrame message handlers

void CMainFrame::OnViewDataViewBar()
{
        BOOL bShow = m_wndDataViewBar.IsVisible();
        ShowControlBar( &m_wndDataViewBar, !bShow, FALSE );
}

void CMainFrame::OnViewSpikeViewBar()
{
        BOOL bShow = m_wndSpikeViewBar.IsVisible();
        ShowControlBar( &m_wndSpikeViewBar, !bShow, FALSE );
}

void CMainFrame::OnUpdateViewDataViewBar( CCmdUI *pCmdUI )
{
        pCmdUI->Enable();
        pCmdUI->SetCheck( m_wndDataViewBar.IsVisible() );
}

void CMainFrame::OnUpdateViewSpikeViewBar( CCmdUI *pCmdUI )
{
        pCmdUI->Enable();
        pCmdUI->SetCheck( m_wndSpikeViewBar.IsVisible() );
}

void CMainFrame::SaveLoadToolBar( BOOL bSave )
{
        // when bSave = TRUE save toolbar setting, FALSE for load settings
        CString strDataViewToolBarReg = _T( "DataViewBar" );
        CString strSpikeViewToolBarReg = _T( "SpikeViewBar" );
        CString strBarStateReg = _T( "BarState" );
        if ( bSave )
        {
                SaveBarState( strBarStateReg );
                m_wndDataViewBar.SaveState( strDataViewToolBarReg );
                m_wndSpikeViewBar.SaveState( strSpikeViewToolBarReg );
        }
        else
        {
                m_wndSpikeViewBar.LoadState( strSpikeViewToolBarReg );
                m_wndDataViewBar.LoadState( strDataViewToolBarReg );
                LoadBarState( strBarStateReg );
        }
}

BOOL CMainFrame::DestroyWindow()
{
        // TODO: Add your specialized code here and/or call the base class
        SaveLoadToolBar( TRUE );

        return CFrameWnd::DestroyWindow();
}