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

// MCDataManager.cpp : implementation of the CMCDataManager class
//

#include "stdafx.h"
#include "MCDataManager.h"

#define MCDATA_PLUGINS "\\plugins\\mcdata"
#define MCDATA_TITLE_FUNCNAME "GetDataTypeTitle"
#define MCDATA_FILTER_FUNCNAME "GetDataTypeFilter"
#define MCDATA_CREATE_FUNCNAME "CreateDataTypeInstance"
static sl4_list_t *get_data_plugins();
static sl4_string_t *get_data_plugin_path();
static sl4_string_t *get_module_path();
static int is_directory( const char *path );

#define MAX_FILE_TYPES 100

CMCDataManager::CMCDataManager( void )
{
        m_arDataType = NULL;
        m_dirPlugin = NULL;
}

CMCDataManager::~CMCDataManager( void )
{
        DeleteDataTypeArray();
        CleanPluginDirectory();
}

CMCDataManager::plugin_info *CMCDataManager::pinfo_new( const char *path )
{
        plugin_info * pinfo = new plugin_info;
        if ( pinfo == NULL )
                return NULL;
        /* resolve file path */
        pinfo->file = sl4_file_new( path );
        if ( pinfo->file == NULL )
        {
                delete pinfo;
                return NULL;
        }
        /* load library */
        path = sl4_file_get_path( pinfo->file );
        pinfo->library = LoadLibrary( path );
        if ( pinfo->library == NULL )
        {
                sl4_file_delete( pinfo->file );
                delete pinfo;
                return NULL;
        }
        /* get address pointer of GetDataTypeTitle() function */
        pinfo->title_func = ( mcdata_title_func_t ) GetProcAddress( pinfo->library, MCDATA_TITLE_FUNCNAME );
        /* get address pointer of GetDataTypeFilter() function */
        pinfo->filter_func = ( mcdata_filter_func_t ) GetProcAddress( pinfo->library, MCDATA_FILTER_FUNCNAME );
        /* get address pointer of instance creation function */
        pinfo->create_func = ( mcdata_create_func_t ) GetProcAddress( pinfo->library, MCDATA_CREATE_FUNCNAME );
        if ( pinfo->title_func == NULL || pinfo->filter_func == NULL || pinfo->create_func == NULL )
        {
                FreeLibrary( pinfo->library );
                sl4_file_delete( pinfo->file );
                delete pinfo;
                return NULL;
        }
        return pinfo;
}

BOOL CMCDataManager::pinfo_delete( plugin_info *pinfo )
{
        if ( pinfo->file != NULL )
                sl4_file_delete( pinfo->file );
        if ( pinfo->library != NULL )
                FreeLibrary( pinfo->library );
        delete pinfo;
        return TRUE;
}

BOOL CMCDataManager::CreateDataTypeArray()
{
        m_arDataType = sl4_array_new( sizeof( plugin_info * ) );
        if ( m_arDataType == NULL )
                return FALSE;
        return TRUE;
}

BOOL CMCDataManager::DeleteDataTypeArray()
{
        if ( m_arDataType != NULL )
        {
                size_t i, len;
                len = sl4_array_length( m_arDataType );
                for ( i = 0; i < len; i++ )
                {
                        plugin_info *pinfo = sl4_array_index( m_arDataType, plugin_info *, i );
                        pinfo_delete( pinfo );
                }
                sl4_array_delete( m_arDataType );
                m_arDataType = NULL;
        }
        return TRUE;
}

BOOL CMCDataManager::AddDataTypeArray( const char *path )
{
        plugin_info * pinfo;
        pinfo = pinfo_new( path );
        if ( pinfo == NULL )
                return FALSE;
        if ( sl4_array_add( m_arDataType, &pinfo ) != 0 )
                return FALSE;
        return TRUE;
}


BOOL CMCDataManager::InitPluginDirectory()
{
        /* get module path */
        sl4_string_t * path;
        char buf[ MAX_PATH ];
        size_t len;
        if ( GetModuleFileName( NULL, buf, MAX_PATH ) == 0 )
                return NULL;
        len = strlen( buf );
        for ( size_t i = len - 1; i > 0; i-- )
        {
                if ( buf[ i ] == '\\' )
                {
                        buf[ i ] = '\0';
                        break;
                }
        }
        path = sl4_string_new( buf );
        if ( path == NULL )
                return FALSE;

        /* get data plugins path */
        if ( sl4_string_append( path, MCDATA_PLUGINS ) != 0 )
        {
                sl4_string_delete( path );
                return -1;
        }

        /* create sl4_file_t instance */
        m_dirPlugin = sl4_file_new( sl4_string_get( path ) );
        sl4_string_delete( path );
        if ( m_dirPlugin == NULL )
                return FALSE;
        /* directory check */
        if ( sl4_file_is_directory( m_dirPlugin ) == 0 )
        {
                sl4_file_delete( m_dirPlugin );
                m_dirPlugin = NULL;
                return FALSE;
        }
        return TRUE;
}

BOOL CMCDataManager::CleanPluginDirectory()
{
        if ( m_dirPlugin == NULL )
        {
                sl4_file_delete( m_dirPlugin );
                m_dirPlugin = NULL;
        }
        return TRUE;
}

BOOL CMCDataManager::FindDataPlugins()
{
        int num = 0;
        /* get file lists */
        HANDLE hFile;
        WIN32_FIND_DATA fData;
        sl4_string_t *pattern = sl4_string_new( sl4_file_get_path( m_dirPlugin ) );
        if ( pattern == NULL )
                return FALSE;
        sl4_string_append( pattern, sl4_file_get_separator() );
        sl4_string_append( pattern, "*" );
        hFile = FindFirstFile( sl4_string_get( pattern ), &fData );
        sl4_string_delete( pattern );
        if ( hFile == INVALID_HANDLE_VALUE )
        {
                return FALSE;
        }
        do
        {
                if ( !( fData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
                {
                        sl4_string_t * fname = sl4_string_new( sl4_file_get_path( m_dirPlugin ) );
                        if ( fname != NULL )
                        {
                                if ( sl4_string_append( fname, sl4_file_get_separator() ) == 0 &&
                                        sl4_string_append( fname, fData.cFileName ) == 0 )
                                        if ( AddDataTypeArray( sl4_string_get( fname ) ) )
                                                num++; /* increment number of plugins */
                                sl4_string_delete( fname );
                        }
                }
        }
        while ( FindNextFile( hFile, &fData ) );
        FindClose( hFile );
        if ( num == 0 )
                return FALSE;
        return TRUE;
}

BOOL CMCDataManager::Initialize()
{
        if ( !CreateDataTypeArray() )
                return FALSE;
        if ( !InitPluginDirectory() )
                return FALSE;
        if ( !FindDataPlugins() )
                return FALSE;
        return TRUE;
}


CMultiChannelData *CMCDataManager::CreateInstance( size_t n )
{
        size_t len;
        len = sl4_array_length( this->m_arDataType );
        if ( n >= len )
                return NULL;
        plugin_info *pinfo = sl4_array_index( m_arDataType, plugin_info *, 0 );
        return pinfo->create_func();
}

BOOL CMCDataManager::InstallFileOpenMenu( CMenu *ParentMenu )
{
        BOOL bReturn = FALSE ;
        if ( ParentMenu != NULL )
        {
                CMenu * FileMenu = NULL;
                CMenu *OpenMenu = NULL;
                UINT FilePosition = 0;
                UINT OpenPosition = 1;
                // get file menu.
                FileMenu = ParentMenu->GetSubMenu( FilePosition );
                if ( FileMenu != NULL )
                {
                        // get open menu.
                        OpenMenu = FileMenu->GetSubMenu( OpenPosition );
                }
                if ( OpenMenu != NULL )
                {
                        size_t i, len;
                        len = sl4_array_length( this->m_arDataType );
                        for ( i = 0; i < len; i++ )
                        {
                                plugin_info *pinfo = sl4_array_index( m_arDataType, plugin_info *, i );
                                const char *title = pinfo->title_func();
                                if ( i == 0 )
                                {
                                        OpenMenu->ModifyMenu( 0, MF_BYPOSITION, ID_MCDATAFILE_OPEN_CMD01 + i, _T( title ) ) ;
                                }
                                else
                                {
                                        OpenMenu->AppendMenu( MF_STRING, ID_MCDATAFILE_OPEN_CMD01 + i, _T( title ) ) ;
                                }
                        }
                        bReturn = TRUE;
                }
        }
        return bReturn ;
}

BOOL CMCDataManager::GetPluginTitle( size_t n, char *buf, size_t buflen )
{
        size_t len;
        len = sl4_array_length( this->m_arDataType );
        if ( n >= len )
                return FALSE;
        plugin_info *pinfo = sl4_array_index( m_arDataType, plugin_info *, n );
        const char *title = pinfo->title_func();
        len = strlen( title );
        if ( len >= buflen )
                return FALSE;
        strcpy( buf, title );
        return TRUE;
}

int CMCDataManager::m_iMaxFileTypes = MAX_FILE_TYPES;