neuromanager/neuromanager/NeuroManagerDoc.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: NeuroManagerDoc.cpp,v 1.4 2006/03/20 09:09:43 orrisroot Exp $ */

// NeuroManagerDoc.cpp : implementation of the CNeuroManagerDoc class
//

#include "stdafx.h"
#include "NeuroManager.h"
#include "NeuroManagerDoc.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CNeuroManagerDoc

IMPLEMENT_DYNCREATE( CNeuroManagerDoc, CDocument )

BEGIN_MESSAGE_MAP( CNeuroManagerDoc, CDocument )
END_MESSAGE_MAP()


// CNeuroManagerDoc construction/destruction

CNeuroManagerDoc::CNeuroManagerDoc()
                : m_strFileName( _T( "" ) )
{
        // TODO: add one-time construction code here
        m_pData = NULL;
        //MessageBox(NULL, "CNeuroManagerDoc()", "Constractor", MB_OK);
        // set menu bar for plugins
        m_MCDataManager.Initialize();
}

CNeuroManagerDoc::~CNeuroManagerDoc()
{
        if ( m_pData )
        {
                delete m_pData;
                m_pData = NULL;
        }
}

BOOL CNeuroManagerDoc::OnNewDocument()
{
        // confirmation
        if ( !m_strFileName.IsEmpty() || m_pData )
        {
                int stat = AfxMessageBox( _T( "Do you want to close current data file" ),
                                          MB_OKCANCEL );
                if ( stat == IDCANCEL )
                        return FALSE;
        }

        if ( !CDocument::OnNewDocument() )
                return FALSE;
        // TODO: add reinitialization code here
        // (SDI documents will reuse this document)
        m_strFileName = _T( "" );
        if ( m_pData )
        {
                delete m_pData;
                m_pData = NULL;
                UpdateAllViews( NULL );
        }

        return TRUE;
}


// CNeuroManagerDoc serialization

void CNeuroManagerDoc::Serialize( CArchive& ar )
{
        if ( ar.IsStoring() )
        {
                // TODO: add storing code here
        }
        else
        {
                // TODO: add loading code here
        }
}


// CNeuroManagerDoc diagnostics

#ifdef _DEBUG
void CNeuroManagerDoc::AssertValid() const
{
        CDocument::AssertValid();
}

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


// get data name
CString CNeuroManagerDoc::getFileName() const
{
        return m_strFileName;
}

BOOL CNeuroManagerDoc::OnOpenDocument( LPCTSTR lpszPathName )
{
        // confirmation
        if ( !m_strFileName.IsEmpty() || m_pData )
        {
                int stat = AfxMessageBox( _T( "Do you want to close current data file" ),
                                          MB_OKCANCEL );
                if ( stat == IDCANCEL )
                        return FALSE;
        }

        if ( !CDocument::OnOpenDocument( lpszPathName ) )
                return FALSE;
        // delete previous data object
        if ( m_pData )
        {
                delete m_pData;
                m_pData = NULL;
        }
        m_strFileName = lpszPathName;
        m_pData = CreateDataInstance();
        BOOL b = m_pData->LoadDataFile( lpszPathName );
        if ( b )
        {
                m_pData->PrintDataInfo();
        }
        UpdateAllViews( NULL );
        return b;
}

BOOL CNeuroManagerDoc::OnSaveDocument( LPCTSTR lpszPathName )
{
        SetModifiedFlag( FALSE );
        return TRUE;
        // disable to call Serialize()
        // return CDocument::OnSaveDocument(lpszPathName);
}

void CNeuroManagerDoc::AttachData( UINT ch ) const
{
        ASSERT( m_pData );
        m_pData->AttachData( ch );
}

void CNeuroManagerDoc::DetachData() const
{
        ASSERT( m_pData );
        m_pData->DetachData();
}

double CNeuroManagerDoc::GetData( QWORD pos ) const
{
        ASSERT( m_pData );
        return m_pData->GetData( pos );
}

double CNeuroManagerDoc::GetYAxisRange( UINT ch ) const
{
        ASSERT( m_pData );
        return m_pData->GetYAxisRange( ch );
}

BOOL CNeuroManagerDoc::IsMapped() const
{
        if ( m_pData )
                return m_pData->IsMapped();
        return FALSE;
}

double CNeuroManagerDoc::GetSamplingRate() const
{
        ASSERT( m_pData );
        return m_pData->GetSamplingRate();
}

double CNeuroManagerDoc::GetPosTime( QWORD pos ) const
{
        ASSERT( m_pData );
        return m_pData->GetPosTime( pos );
}

UINT CNeuroManagerDoc::GetChannelNumber() const
{
        ASSERT( m_pData );
        return m_pData->GetChannelNumber();
}

QWORD CNeuroManagerDoc::GetDataLength() const
{
        ASSERT( m_pData );
        return m_pData->GetDataLength();
}

UINT CNeuroManagerDoc::GetBitLength() const
{
        ASSERT( m_pData );
        return m_pData->GetBitLength();
}

BOOL CNeuroManagerDoc::GetByteSwap() const
{
        ASSERT( m_pData );
        return m_pData->GetByteSwap();
}

BOOL CNeuroManagerDoc::SetPlguinMenu( CMenu *ParentMenu )
{
        BOOL bReturn;
        bReturn = m_MCDataManager.InstallFileOpenMenu( ParentMenu );
        if ( bReturn )
                AfxGetMainWnd() ->DrawMenuBar();
        return bReturn;
}

CMultiChannelData * CNeuroManagerDoc::CreateDataInstance()
{
        return this->m_MCDataManager.CreateInstance( 0 );
}

BOOL CNeuroManagerDoc::GetPluginTitle( size_t n, char *buf, size_t buflen )
{
        return m_MCDataManager.GetPluginTitle( n, buf, buflen );
}