/*---------------------------------------------------------------------------------*/
/* Includes                                                                        */
/*---------------------------------------------------------------------------------*/

#define _IMRD_C_



#include <drummer.h>





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

NDT_Status  DR_Instrument_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  *Args_Ptr)
{
    NDT_Command_Name  Command_Name;


    switch( Command)
    {
        case NDD_CMD_MANAGER_VERSION:
        {
	    ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name  *);


            Command_Name = "NDD_CMD_MANAGER_VERSION";

            *Version_Name_Ptr = "$Revision: 1.0 $   $Name: Instrument_Manager $   $Date: 2021/12/12 21:27:12 $   $Author: agibert $";

            return( NDS_OK);
        }

        case NDD_CMD_INDEX_GET:
        {
            /*
	      ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id  *);
	      ND_VA_ARG_GET( Reply_Command_Ptr,  *Args_Ptr, NDT_Command  *);
	      ND_VA_ARG_GET( Cmd,                *Args_Ptr, NDT_Command);
	      ND_VA_ARG_GET( Value_Ptr,          *Args_Ptr, void  *);
            */

	    ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id  *);
	    ND_VA_ARG_GET( Reply_Command_Ptr,  *Args_Ptr, NDT_Command  *);
	    ND_VA_ARG_GET( Cmd,                *Args_Ptr, NDT_Command);
	    ND_VA_ARG_GET( Instrument_Ptr,     *Args_Ptr, DRT_Instrument  *);


            Command_Name = "NDD_CMD_INDEX_GET";

            switch(Cmd)
            {
                /*
		  case NDT_CMD_SOME_USER_CMD:
		  {
		  *Reply_Index_Id_Ptr = 0;
		  *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
		  break;
		  }
		  ...
                */

                case NDD_CMD_INDEX0_PRINT:
                {
                    *Reply_Index_Id_Ptr = 0;
                    *Reply_Command_Ptr = Cmd;
                    break;
                }

                case NDD_CMD_INDEX1_PRINT:
                {
                    *Reply_Index_Id_Ptr = 1;
                    *Reply_Command_Ptr = Cmd;
                    break;
                }

	        default:
                {
                    *Reply_Index_Id_Ptr = Index_Id;
                    *Reply_Command_Ptr = Cmd;
                    break;
                }
            }

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_ALLOC:
        {
            /*
	      ND_VA_ARG_GET(    Value_Ptr_Ptr, *Args_Ptr, void  **);

	      ND_VA_LIST_OPEN(  user_args,     *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,      user_args, user_type);
	      ND_VA_ARG_GET(    ...,            user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Instrument_Ptr_Ptr, *Args_Ptr, DRT_Instrument  **);

	    ND_VA_LIST_OPEN(  user_args,          *Args_Ptr);
	    ND_VA_ARG_GET(    Name,                user_args, char  *);
	    ND_VA_ARG_GET(    FileName,            user_args, char  *);
	    ND_VA_ARG_GET(    Gain,                user_args, double);
	    ND_VA_ARG_GET(    Sample_Ptr,          user_args, char  *);
	    ND_VA_ARG_GET(    Sample_Size,         user_args, long);

	    ND_VA_LIST_CLOSE( user_args);


            Command_Name = "NDD_CMD_VALUE_ALLOC";

            if( ( *Instrument_Ptr_Ptr = (DRT_Instrument  *)malloc( sizeof( DRT_Instrument))) != NULL)
            {
		( *Instrument_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number;
		    
		strncpy( ( *Instrument_Ptr_Ptr)->Name,     Name,     NAME_LEN);
		strncpy( ( *Instrument_Ptr_Ptr)->FileName, FileName, FILENAME_LEN);

		(*Instrument_Ptr_Ptr)->Name[        NAME_LEN] = '\0';
		(*Instrument_Ptr_Ptr)->FileName[FILENAME_LEN] = '\0';

		( *Instrument_Ptr_Ptr)->Gain        = Gain;
		( *Instrument_Ptr_Ptr)->Sample_Ptr  = Sample_Ptr;
		( *Instrument_Ptr_Ptr)->Sample_Size = Sample_Size;
		
		return( NDS_OK);
            }
            else
            {
                return( NDS_KO);
            }
        }

        case NDD_CMD_VALUE_FREE:
        {
            /*
	      ND_VA_ARG_GET(    Value_Ptr, *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN(  user_args, *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,  user_args, user_type);
	      ND_VA_ARG_GET(    ...,        user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Instrument_Ptr, *Args_Ptr, DRT_Instrument  *);


            Command_Name = "NDD_CMD_VALUE_FREE";


            free( Instrument_Ptr);

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_COMP:
        {
            /*
	      ND_VA_ARG_GET(    Value1_Ptr,  *Args_Ptr, void  *);
	      ND_VA_ARG_GET(    Value2_Ptr,  *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN(  user_args,   *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,    user_args, user_type);
	      ND_VA_ARG_GET(    ...,          user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Instrument1_Ptr, *Args_Ptr, DRT_Instrument  *);
	    ND_VA_ARG_GET(    Instrument2_Ptr, *Args_Ptr, DRT_Instrument  *);

	    long  rc;

	    
            Command_Name = "NDD_CMD_VALUE_COMP";

            switch( Index_Id)
            {
	        case 0:
		{
		    rc = Instrument1_Ptr->Id - Instrument2_Ptr->Id;
		    break;
		}

	        case 1:
		{
		    rc = strcmp( Instrument1_Ptr->Name, Instrument2_Ptr->Name);
		    break;
		}
		
	        default:
		{
		    printf( "Unknown COMP idx (%d) !\n", Index_Id);
		    return( NDS_KO);
		}
	    }

	    if( rc < 0)
	    {
		return( NDS_LOWER);
	    }
	    else
	    {
		if( rc > 0)
		{
		    return( NDS_GREATER);
		}
		else
		{
		    return( NDS_EQUAL);
		}
	    }
        }

        case NDD_CMD_VALUE_ADD:
        {
            /*
	      ND_VA_ARG_GET(    Value_Ptr, *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN(  user_args, *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,  user_args, user_type);
	      ND_VA_ARG_GET(    ...,        user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */


            Command_Name = "NDD_CMD_VALUE_ADD";

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_REMOVE:
        {
            /*
	      ND_VA_ARG_GET(   Value_Ptr, *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN( user_args, *Args_Ptr);

	      ND_VA_ARG_GET(   user_data,  user_args, user_type);
	      ND_VA_ARG_GET(   ...,        user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */


            Command_Name = "NDD_CMD_VALUE_REMOVE";

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_PRINT:
        {
	    /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	      ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	      ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	      ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	      ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	      ND_VA_LIST_OPEN(  user_args,         lib_args);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
	      ND_VA_LIST_CLOSE( lib_args);

	      void  *Value_Ptr = Node_Ptr->Value;
            */
	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	    ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	    ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	    ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	    ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	    ND_VA_LIST_OPEN(  user_args,         lib_args);

	    ND_VA_ARG_GET(    Count_Ptr,         user_args, long  *);

	    ND_VA_LIST_CLOSE( user_args);
	    ND_VA_LIST_CLOSE( lib_args);

            DRT_Instrument  *Instrument_Ptr = Node_Ptr->Value;


            Command_Name = "NDD_CMD_VALUE_PRINT";

	    if( DR_Instrument_Dump( Instrument_Ptr, ++(*Count_Ptr)) != DRS_OK)
	    {
		return( NDS_KO);
	    }
	    else
	    {
		return( NDS_OK);
	    }
        }

        case NDD_CMD_INFO_PRINT:
        {
            /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	      ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	      ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	      ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	      ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	      ND_VA_LIST_OPEN(  user_args,         lib_args);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
	      ND_VA_LIST_CLOSE( lib_args);
            */


            Command_Name = "NDD_CMD_INFO_PRINT";

            return( NDS_OK);

        }

        case NDD_CMD_INDEX0_PRINT:
        case NDD_CMD_INDEX1_PRINT:
        {
            /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	    ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               user_args, FILE  *);
	    ND_VA_ARG_GET(    Count_Ptr,         user_args, long  *);

	    ND_VA_LIST_CLOSE( user_args);

            DRT_Instrument  *Instrument_Ptr = Node_Ptr->Value;


            Command_Name = "NDD_CMD_INDEX_PRINT";

	    if( DR_Instrument_Dump( Instrument_Ptr, ++(*Count_Ptr)) != DRS_OK)
	    {
		return( NDS_KO);
	    }
	    else
	    {
		return( NDS_OK);
	    }
        }
/*
        case NDD_CMD_PHONEBOOK_SAVE:
        {
            /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */
/*
	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	    ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               user_args,  FILE  *);
	    ND_VA_ARG_GET(    Count_Ptr,         user_args,  long  *);

	    ND_VA_LIST_CLOSE( user_args);

            DRT_Instrument  *Instrument_Ptr = Node_Ptr->Value;


            Command_Name = "NDD_CMD_PHONEBOOK_SAVE";

	    fprintf( Out, "%s:%s:%s:%s\n", Instrument_Ptr->Number, Instrument_Ptr->Name, Instrument_Ptr->Address, Instrument_Ptr->Email);
	    (*Count_Ptr)++;
		
	    return( NDS_OK);
        }
*/
        default:
        {
            printf( "Instrument_Manager() called with an undefined command %d\n", Command);
            return( NDS_ERRAPI);

        }
    }

    printf( "Instrument_Manager() called with command %d (%s)\n", Command, Command_Name);
    return( NDS_OK);
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

NDT_Status  DR_Kit_Manager( NDT_Root  *Root_Ptr, NDT_Index_Id  Index_Id, NDT_Node  *Node_Ptr, NDT_Command  Command, va_list  *Args_Ptr)
{
    NDT_Command_Name  Command_Name;


    switch( Command)
    {
        case NDD_CMD_MANAGER_VERSION:
        {
	    ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name  *);


            Command_Name = "NDD_CMD_MANAGER_VERSION";

            *Version_Name_Ptr = "$Revision: 1.0 $   $Name: Kit_Manager $   $Date: 2021/12/12 21:27:12 $   $Author: agibert $";

            return( NDS_OK);
        }

        case NDD_CMD_INDEX_GET:
        {
            /*
	      ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id  *);
	      ND_VA_ARG_GET( Reply_Command_Ptr,  *Args_Ptr, NDT_Command  *);
	      ND_VA_ARG_GET( Cmd,                *Args_Ptr, NDT_Command);
	      ND_VA_ARG_GET( Value_Ptr,          *Args_Ptr, void  *);
            */

	    ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id  *);
	    ND_VA_ARG_GET( Reply_Command_Ptr,  *Args_Ptr, NDT_Command  *);
	    ND_VA_ARG_GET( Cmd,                *Args_Ptr, NDT_Command);
	    ND_VA_ARG_GET( Kit_Ptr,            *Args_Ptr, DRT_Kit  *);


            Command_Name = "NDD_CMD_INDEX_GET";

            switch(Cmd)
            {
                /*
		  case NDT_CMD_SOME_USER_CMD:
		  {
		  *Reply_Index_Id_Ptr = 0;
		  *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
		  break;
		  }
		  ...
                */

                case NDD_CMD_INDEX0_PRINT:
                {
                    *Reply_Index_Id_Ptr = 0;
                    *Reply_Command_Ptr = Cmd;
                    break;
                }

                case NDD_CMD_VALUE_PRINT:
                case NDD_CMD_INDEX1_PRINT:
                {
                    *Reply_Index_Id_Ptr = 1;
                    *Reply_Command_Ptr = Cmd;
                    break;
                }

	        default:
                {
                    *Reply_Index_Id_Ptr = Index_Id;
                    *Reply_Command_Ptr = Cmd;
                    break;
                }
            }

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_ALLOC:
        {
            /*
	      ND_VA_ARG_GET(    Value_Ptr_Ptr, *Args_Ptr, void  **);

	      ND_VA_LIST_OPEN(  user_args,     *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,      user_args, user_type);
	      ND_VA_ARG_GET(    ...,            user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Kit_Ptr_Ptr, *Args_Ptr, DRT_Kit  **);

	    ND_VA_LIST_OPEN(  user_args,   *Args_Ptr);

	    ND_VA_ARG_GET(    Name,         user_args, char  *);
	    ND_VA_ARG_GET(    Desc,         user_args, char  *);
	    ND_VA_ARG_GET(    FileName,     user_args, char  *);

	    ND_VA_LIST_CLOSE( user_args);

	    NDT_Status  nd_status;

	    
            Command_Name = "NDD_CMD_VALUE_ALLOC";

            if( ( *Kit_Ptr_Ptr = (DRT_Kit  *)malloc( sizeof( DRT_Kit))) != NULL)
            {
		( *Kit_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number;
		    
		strncpy( ( *Kit_Ptr_Ptr)->Name,     Name,     NAME_LEN);
		strncpy( ( *Kit_Ptr_Ptr)->Desc,     Desc,     DESC_LEN);
		strncpy( ( *Kit_Ptr_Ptr)->FileName, FileName, FILENAME_LEN);

		(*Kit_Ptr_Ptr)->Name[        NAME_LEN] = '\0';
		(*Kit_Ptr_Ptr)->Desc[        DESC_LEN] = '\0';
		(*Kit_Ptr_Ptr)->FileName[FILENAME_LEN] = '\0';

		if( ( nd_status = ND_DataStruct_Open( &((*Kit_Ptr_Ptr)->Instrument_DS_Ptr), DRD_INSTRUMENT_DS_INDEX_NB, DRG_Instrument_DS_Index_Tab_Initial, "Instrument_Manager", DR_Instrument_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK)
		{
		    printf( "DR_Instrument_Manager: ND_DataStruct_Open() failed (%d) !\n", nd_status);
		    return( NDS_KO);
		}

		return( NDS_OK);
            }
            else
            {
                return( NDS_KO);
            }
        }

        case NDD_CMD_VALUE_FREE:
        {
            /*
	      ND_VA_ARG_GET(    Value_Ptr, *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN(  user_args, *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,  user_args, user_type);
	      ND_VA_ARG_GET(    ...,        user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Kit_Ptr, *Args_Ptr, DRT_Kit  *);

	    NDT_Status  nd_status;


            Command_Name = "NDD_CMD_VALUE_FREE";

	    if( ( nd_status = ND_DataStruct_Close( Kit_Ptr->Instrument_DS_Ptr)) != NDS_OK)
	    {
		printf( "Can't close Kit_DS (%d)!\n", nd_status);
		return( DRS_KO);
	    }

	    free( Kit_Ptr);

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_COMP:
        {
            /*
	      ND_VA_ARG_GET(    Value1_Ptr,  *Args_Ptr, void  *);
	      ND_VA_ARG_GET(    Value2_Ptr,  *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN(  user_args,   *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,    user_args, user_type);
	      ND_VA_ARG_GET(    ...,          user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Kit1_Ptr, *Args_Ptr, DRT_Kit  *);
	    ND_VA_ARG_GET(    Kit2_Ptr, *Args_Ptr, DRT_Kit  *);

	    long  rc;

	    
            Command_Name = "NDD_CMD_VALUE_COMP";

            switch( Index_Id)
            {
	        case 0:
		{
		    rc = Kit1_Ptr->Id - Kit2_Ptr->Id;
		    break;
		}

	        case 1:
		{
		    rc = strcmp( Kit1_Ptr->Name, Kit2_Ptr->Name);
		    break;
		}
		
	        default:
		{
		    printf( "Unknown COMP idx (%d) !\n", Index_Id);
		    return( NDS_KO);
		}
	    }

	    if( rc < 0)
	    {
		return( NDS_LOWER);
	    }
	    else
	    {
		if( rc > 0)
		{
		    return( NDS_GREATER);
		}
		else
		{
		    return( NDS_EQUAL);
		}
	    }
        }

        case NDD_CMD_VALUE_ADD:
        {
            /*
	      ND_VA_ARG_GET(    Value_Ptr, *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN(  user_args, *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,  user_args, user_type);
	      ND_VA_ARG_GET(    ...,        user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    
            Command_Name = "NDD_CMD_VALUE_ADD";

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_REMOVE:
        {
            /*
	      ND_VA_ARG_GET(   Value_Ptr, *Args_Ptr, void  *);

	      ND_VA_LIST_OPEN( user_args, *Args_Ptr);

	      ND_VA_ARG_GET(   user_data,  user_args, user_type);
	      ND_VA_ARG_GET(   ...,        user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    
            Command_Name = "NDD_CMD_VALUE_REMOVE";

            return( NDS_OK);
        }

        case NDD_CMD_VALUE_PRINT:
        {
	    /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	      ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	      ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	      ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	      ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	      ND_VA_LIST_OPEN(  user_args,         lib_args);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
	      ND_VA_LIST_CLOSE( lib_args);

	      void  *Value_Ptr = Node_Ptr->Value;
            */

	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	    ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	    ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	    ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	    ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	    ND_VA_LIST_OPEN(  user_args,         lib_args);

	    ND_VA_ARG_GET(    Count_Ptr,         user_args, long  *);

	    ND_VA_LIST_CLOSE( user_args);
	    ND_VA_LIST_CLOSE( lib_args);

            DRT_Kit  *Kit_Ptr = Node_Ptr->Value;


            Command_Name = "NDD_CMD_VALUE_PRINT";

	    if( DR_Kit_Dump( Kit_Ptr, ++(*Count_Ptr)) != DRS_OK)
	    {
		return( NDS_KO);
	    }
	    else
	    {
		return( NDS_OK);
	    }
        }

        case NDD_CMD_INFO_PRINT:
        {
            /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	      ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	      ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	      ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	      ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	      ND_VA_LIST_OPEN(  user_args,         lib_args);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
	      ND_VA_LIST_CLOSE( lib_args);
            */

	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);
	    
	    ND_VA_LIST_OPEN(  lib_args,         *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               lib_args,  FILE  *);
	    ND_VA_ARG_GET(    Recursive_Mode,    lib_args,  NDT_Recursive_Mode);
	    ND_VA_ARG_GET(    Recursive_Depth,   lib_args,  NDT_Recursive_Depth);
	    ND_VA_ARG_GET(    Recursive_Offset,  lib_args,  NDT_Recursive_Offset);

	    ND_VA_LIST_CLOSE( lib_args);
	    
	    NDT_Status   nd_status;
            DRT_Kit     *Kit_Ptr = Node_Ptr->Value;

	    
	    Command_Name = "NDD_CMD_INFO_PRINT";

	    if( ( nd_status = ND_DataStruct_Info_Print( Out, Kit_Ptr->Instrument_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
	    {
		printf( "ND_DataStruct_Info_Print() failed (%d) !\n", nd_status);
		return( DRS_KO);
	    }

	    return( NDS_OK);

        }

        case NDD_CMD_INDEX0_PRINT:
        case NDD_CMD_INDEX1_PRINT:
        {
            /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */

	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	    ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               user_args, FILE  *);
	    ND_VA_ARG_GET(    Count_Ptr,         user_args, long  *);

	    ND_VA_LIST_CLOSE( user_args);

            DRT_Kit  *Kit_Ptr = Node_Ptr->Value;


            Command_Name = "NDD_CMD_INDEX_PRINT";

	    if( DR_Kit_Dump( Kit_Ptr, ++(*Count_Ptr)) != DRS_OK)
	    {
		return( NDS_KO);
	    }
	    else
	    {
		return( NDS_OK);
	    }
        }
/*
        case NDD_CMD_PHONEBOOK_SAVE:
        {
            /*
	      ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	      ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	      ND_VA_ARG_GET(    user_data,         user_args, user_type);
	      ND_VA_ARG_GET(    ...,               user_args, ...);

	      ND_VA_LIST_CLOSE( user_args);
            */ /*
	    ND_VA_ARG_GET(    Next_Node_Ptr,    *Args_Ptr,  NDT_Node  *);

	    ND_VA_LIST_OPEN(  user_args,        *Args_Ptr);

	    ND_VA_ARG_GET(    Out,               user_args,  FILE  *);
	    ND_VA_ARG_GET(    Count_Ptr,         user_args,  long  *);

	    ND_VA_LIST_CLOSE( user_args);

            DRT_Kit  *Kit_Ptr = Node_Ptr->Value;


            Command_Name = "NDD_CMD_PHONEBOOK_SAVE";

	    fprintf( Out, "%s:%s:%s:%s\n", Kit_Ptr->Number, Kit_Ptr->Name, Kit_Ptr->Address, Kit_Ptr->Email);
	    (*Count_Ptr)++;
		
	    return( NDS_OK);
        }
*/
        default:
        {
            printf( "Kit_Manager() called with an undefined command %d\n", Command);
            return( NDS_ERRAPI);
        }
    }

    printf( "Kit_Manager() called with command %d (%s)\n", Command, Command_Name);
    return( NDS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_Instrument_Add                                                               */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Instrument_Add( DRT_Instrument  **Instrument_Ptr_Ptr, NDT_Root  *DS_Ptr, char  *Name, char  *FileName, double  Gain, char  *Sample_Ptr, long  Sample_Size)
{
    NDT_Status   nd_status;
    

    if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void  **)Instrument_Ptr_Ptr, Name, FileName, Gain, Sample_Ptr, Sample_Size)) != NDS_OK)
    {
	printf( "Can't allocate new instrument: ND_Value_Alloc() failed (%d) !\n", nd_status);
	return( DRS_KO);
    }
    else
    {
	if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void  *)*Instrument_Ptr_Ptr)) != NDS_OK)
	{
	    printf( "Can't add new kit: ND_Value_Add() failed (%d) !\n", nd_status);
	    return( DRS_KO);
	}
    }

    return( DRS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_Instrument_Dump                                                                     */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Instrument_Dump( DRT_Instrument  *Instrument_Ptr, long  count)
{
    NDT_Status   nd_status;
    

    fprintf( stderr, "        %03d) Instrument: ", count);
    fprintf( stderr, "          Id: (% 3d)   Name: [%s]   File Name: [%s]   Gain: (%f)   Sample: [%lx]   Sample Size: (%d)\n",
	     Instrument_Ptr->Id, Instrument_Ptr->Name, Instrument_Ptr->FileName, Instrument_Ptr->Gain, Instrument_Ptr->Sample_Ptr, Instrument_Ptr->Sample_Size);
//    fprintf( stderr, "\n");

    return( DRS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_Kit_Add                                                                      */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Kit_Add( DRT_Kit  **Kit_Ptr_Ptr, NDT_Root  *DS_Ptr, char  *Name, char  *Desc, char  *FileName)
{
    NDT_Status   nd_status;
    

    if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void  **)Kit_Ptr_Ptr, Name, Desc, FileName)) != NDS_OK)
    {
	printf( "Can't allocate new kit: ND_Value_Alloc() failed (%d) !\n", nd_status);
	return( DRS_KO);
    }
    else
    {
	if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void  **)*Kit_Ptr_Ptr)) != NDS_OK)
	{
	    printf( "Can't add new kit: ND_Value_Add() failed (%d) !\n", nd_status);
	    return( DRS_KO);
	}
    }

    return( DRS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_Kit_Dump                                                                     */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Kit_Dump( DRT_Kit  *Kit_Ptr, long  count)
{
    NDT_Status   nd_status;
    long         count2;
    
    

    fprintf( stderr, "  %03d) DrumKit:", count);
    fprintf( stderr, "      Id: (% 3d)   Name: [%s]   Descrition: [%.32s]   File Name: [%s]\n", Kit_Ptr->Id, Kit_Ptr->Name, Kit_Ptr->Desc, Kit_Ptr->FileName);
    fprintf( stderr, "      Instruments List:\n");

    if( Kit_Ptr->Instrument_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number == 0)
    {
	fprintf( stderr, "        Empty list!\n");
    }
    else
    {
	count2 = 0;
	
	if( ( nd_status = ND_DataStruct_Value_Print( stderr, Kit_Ptr->Instrument_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count2)) != NDS_OK)
	{
	    printf( "Cant't dump intruments: ND_DataStruct_Traverse() failed (%d) !\n", nd_status);
	    return( DRS_KO);
	}
    }

    fprintf( stderr, "\n");

    return( DRS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_Kits_Load                                                                    */
/*---------------------------------------------------------------------------------*/

void  element_names_print( xmlNode  *xml_node, int  depth)
{
    xmlNode  *xml_cur_node;
    

    for( xml_cur_node = xml_node; xml_cur_node; xml_cur_node = xml_cur_node->next)
    {
	if( xml_cur_node->type == XML_ELEMENT_NODE)
	{
	    printf( "% *cnode type: Element, name: %s\n", depth*2, ' ', xml_cur_node->name);
	}

	element_names_print( xml_cur_node->children,  depth + 1);
    }
}





/*---------------------------------------------------------------------------------*/
/* DR_XML_Value_Get                                                                */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_XML_Value_Get( char  *Value_Ptr, long  Max_Len, xmlDocPtr  Xml_Doc, xmlXPathContextPtr  Xml_XpathCtx, char  *Xpath_Request)
{
    DRT_Status          status;
    xmlXPathObjectPtr   xml_xpathobj;
    xmlNodeSetPtr       nodeset;
    char               *tmpval_ptr;
    long                tmpval_len;
    
    
    if( ( xml_xpathobj = xmlXPathEvalExpression( Xpath_Request, Xml_XpathCtx)) == NULL)
    {
	fprintf( stderr, "xmlXPathEvalExpression failed!\n");
	status = DRS_KO;
    }
    else
    {
	nodeset = xml_xpathobj->nodesetval;

	if( xmlXPathNodeSetIsEmpty( nodeset))
	{
	    fprintf( stderr, "[%s] not found!\n", Xpath_Request);
	    status = DRS_KO;
	}
	else
	{
	    if( ( tmpval_ptr = xmlNodeListGetString( Xml_Doc, nodeset->nodeTab[0]->xmlChildrenNode, 1)) == NULL)
	    {
		fprintf( stderr, "[%s] value not found!\n", Xpath_Request);
		status = DRS_KO;
	    }
	    else
	    {
		fprintf( stderr, "[%s] = [%s] found!\n", nodeset->nodeTab[0]->name, tmpval_ptr);

		if( ( tmpval_len = strlen( tmpval_ptr)) > Max_Len)
		{
		    fprintf( stderr, "Value too long (%d)>(%d)!\n", tmpval_len, Max_Len);
		    status = DRS_OK;
		}
		else
		{
		    strcpy( Value_Ptr, tmpval_ptr);
		    status = DRS_OK;
		}
	    }
	    
	    xmlFree( tmpval_ptr);
	}
    }

    return( status);
}





/*---------------------------------------------------------------------------------*/
/* DR_XML_Node_Exist                                                               */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_XML_Node_Exist( xmlDocPtr  Xml_Doc, xmlXPathContextPtr  Xml_XpathCtx, char  *Xpath_Request)
{
    DRT_Status          status;
    xmlXPathObjectPtr   xml_xpathobj;
    xmlNodeSetPtr       nodeset;
    char               *tmpval_ptr;
    long                tmpval_len;
    
    
    if( ( xml_xpathobj = xmlXPathEvalExpression( Xpath_Request, Xml_XpathCtx)) == NULL)
    {
	fprintf( stderr, "xmlXPathEvalExpression failed!\n");
	status = DRS_KO;
    }
    else
    {
	nodeset = xml_xpathobj->nodesetval;

	if( xmlXPathNodeSetIsEmpty( nodeset))
	{
	    fprintf( stderr, "[%s] not found!\n", Xpath_Request);
	    status = DRS_KO;
	}
	else
	{
	    fprintf( stderr, "[%s] found!\n", Xpath_Request);
	    status = DRS_OK;
	}
    }

    return( status);
}





/*---------------------------------------------------------------------------------*/
/* DR_Kit_Load                                                                     */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Kit_Load( DRT_Base  *Base_Ptr, char  *FileName)
{
    DRT_Status          status;
    NDT_Status          nd_status;
    DRT_Kit             kit_template;
    DRT_Kit            *kit_ptr;
    DRT_Instrument      instrument_template;
    DRT_Instrument     *instrument_ptr;
    char                tmp_str[256];
    char                xpath_instrument[256];
    char                xpath_value[256];
    xmlDocPtr           xml_doc;
    xmlXPathContextPtr  xml_xpathCtx;
    xmlXPathObjectPtr   xml_xpathObj;
    int                 i;


    fprintf( stderr, "Loading: [%s]...\n", FileName);
    
    if( strlen( FileName) > FILENAME_LEN)
    {
	fprintf( stderr, "Kit file name too long [%s]!", FileName);
	status = DRS_KO;
    }
    else
    {
	strcpy( kit_template.FileName, FileName);

	if( ( xml_doc = xmlParseFile( kit_template.FileName)) == NULL)
	{
	    fprintf( stderr, "xml_doc failed!\n");
	    status = DRS_KO;
	}
	else
	{
	    if( ( xml_xpathCtx = xmlXPathNewContext( xml_doc)) == NULL)
	    {
		fprintf( stderr, "xmlXPathNewContext failed!\n");
		status = DRS_KO;
	    }
	    else
	    {
		if( xmlXPathRegisterNs( xml_xpathCtx, "drumkit", "http://www.hydrogen-music.org/drumkit") != 0)
		{
		    fprintf( stderr,"Error: unable to register default NS!\n");
		    status = DRS_KO;
		}

		if( ( status = DR_XML_Node_Exist( xml_doc, xml_xpathCtx, XML_XPATH_DRUMKIT_BASE_STR) != DRS_OK))
		{
		    fprintf( stderr, "Bad drumkit file!\n");
		}
		else
		{
		    if( ( status = DR_XML_Value_Get( kit_template.Name, NAME_LEN, xml_doc, xml_xpathCtx, XML_XPATH_DRUMKIT_KIT_NAME_FULL)) != DRS_OK)
		    {
			fprintf( stderr, "Name not found!\n");
		    }
		    else if( DR_XML_Value_Get( kit_template.Desc, DESC_LEN, xml_doc, xml_xpathCtx, XML_XPATH_DRUMKIT_KIT_INFO_FULL) != DRS_OK)
		    {
			fprintf( stderr, "Info not found!\n");
			strcpy( kit_template.Desc, "");
		    }

		    if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, kit_template.Name, kit_template.Desc, kit_template.FileName)) != DRS_OK)
		    {
			fprintf( stderr, "Can't create a new kit!\n");
		    }
		    else
		    {
			fprintf( stderr, "New kit!\n");

			status = DRS_OK;
			i = 1;
			while( ( status == DRS_OK)
			       && ( sprintf( xpath_instrument, XML_XPATH_DRUMKIT_INSTRUMENT_FULL, i) > 0)
			       && ( DR_XML_Node_Exist( xml_doc, xml_xpathCtx, xpath_instrument) == DRS_OK))
			{
			    strcpy( xpath_value, xpath_instrument);
//			    strcat( xpath_value, "/drumkit:id");
			    strcat( xpath_value, XML_XPATH_DRUMKIT_ID_STR);
			
			    if( ( status = DR_XML_Value_Get( tmp_str, 256, xml_doc, xml_xpathCtx, xpath_value)) != DRS_OK)
			    {
				fprintf( stderr, "Instrument id not found!\n");
			    }
			    else
			    {
				instrument_template.Id = atoi( tmp_str);

				strcpy( xpath_value, xpath_instrument);
//				strcat( xpath_value, "/drumkit:name");
				strcat( xpath_value, XML_XPATH_DRUMKIT_NAME_STR);
				
				if( ( status = DR_XML_Value_Get( instrument_template.Name, NAME_LEN, xml_doc, xml_xpathCtx, xpath_value)) != DRS_OK)
				{
				    fprintf( stderr, "Instrument name not found!\n");
				    strcpy( instrument_template.Name, "");
				    status = DRS_OK;
				}

				strcpy( xpath_value, xpath_instrument);
				strcat( xpath_value, XML_XPATH_DRUMKIT_LAYER_FILENAME_STR);
    
				if( ( status = DR_XML_Value_Get( instrument_template.FileName, FILENAME_LEN, xml_doc, xml_xpathCtx, xpath_value)) != DRS_OK)
				{
				    fprintf( stderr, "Instrument file name not found!\n");
				    strcpy( instrument_template.FileName, "");
				    status = DRS_OK;
				}

				if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, instrument_template.Name, instrument_template.FileName, 1.01, NULL, 0)) != DRS_OK)
				{
				    fprintf( stderr, "Can't create a new instrument!\n");
				}
				else
				{
				    fprintf( stderr, "New Instrument!\n");
				    i++;
				}
			    }
			}			
		    }
		}
	    
		xmlXPathFreeContext( xml_xpathCtx);
	    }
      	
	    xmlFreeDoc( xml_doc);
	}
    }
    
    xmlCleanupParser();

    return( status);
}





/*---------------------------------------------------------------------------------*/
/* DR_Kits_Load                                                                    */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Kits_Load( DRT_Base  *Base_Ptr)
{
    DRT_Status   status;
    NDT_Status   nd_status;
    char         glob_pattern[] = "~/.hydrogen/data/drumkits/*/drumkit.xml";
//    char         glob_pattern[] = "~/.hydrogen/data/drumkits/AVL-BlackPearl-4A-1.1/drumkit.xml";
//    char         glob_pattern[] = "~/.hydrogen/data/drumkits/Mars Lindrum: 02-Kit 2/drumkit.xml";
    glob_t       glob_struct;
    int          i;
    
    
    LIBXML_TEST_VERSION;

    if( glob( glob_pattern, (GLOB_NOSORT + GLOB_TILDE), NULL, &glob_struct) != 0)
    {
	fprintf( stderr, "glob() error!\n");
	status = DRS_KO;
    }
    else
    {
	for( i = 0; i < glob_struct.gl_pathc; i++)
	{
//	    printf( "[%s]\n", glob_struct.gl_pathv[i]);
	    
	    if( ( status = DR_Kit_Load( Base_Ptr, glob_struct.gl_pathv[i])) != DRS_OK)
	    {
		fprintf( stderr, "Can't load kit [%s]!\n", glob_struct.gl_pathv[i]);
	    }
	}
	
	if( ( nd_status = ND_DataStruct_Convert( Base_Ptr->Kit_DS_Ptr, DRG_Kit_DS_Index_Tab_Final)) != NDS_OK)
	{
	    fprintf( stderr, "ND_DataStruct_Convert() failed (%d) !\n", status);
	    status = DRS_KO;
	}
	else
	{
	    status = DRS_OK;
	}
    }
    
    globfree( &glob_struct);
	
    return( status);
}


		    
/*		
		if( ( xml_xpathObj = xmlXPathEvalExpression( "/drumkit:drumkit_info/drumkit:name", xml_xpathCtx)) == NULL)
		{
		    fprintf( stderr, "xmlXPathEvalExpression failed!\n");
		    status = DRS_KO;
		}
		else
		{
		    xmlNodeSetPtr nodeset = xml_xpathObj->nodesetval;

		    if( !xmlXPathNodeSetIsEmpty( xml_xpathObj->nodesetval))
		    {
			fprintf( stderr, "Name [%s] found!\n", nodeset->nodeTab[0]->name);

			int i;
			char *keyword;
			
			for( i=0; i < nodeset->nodeNr; i++)
			{
			    keyword = xmlNodeListGetString( xml_doc, nodeset->nodeTab[i]->xmlChildrenNode, 1);
			    printf( "keyword: %s\n", keyword);
			    xmlFree( keyword);
			}
		    }

		    DRT_Status  DR_XML_Value_Get( char  **Value_Ptr_Ptr, xmlDocPtr  Xml_Doc, xmlXPathContextPtr  xml_xpathCtx, char  *Xpath_Request)
		    {
			xmlXPathObjectPtr   xml_xpathobj;
			xmlNodeSetPtr       nodeset;

			
			if( ( xml_xpathobj = xmlXPathEvalExpression( "/drumkit:drumkit_info/drumkit:name", xml_xpathCtx)) == NULL)
			{
			    fprintf( stderr, "xmlXPathEvalExpression failed!\n");
			    status = DRS_KO;
			}
			else
			{
			    nodeset = xml_xpathobj->nodesetval;

			    if( !xmlXPathNodeSetIsEmpty( nodeset))
			    {
				(*Value_Ptr_Ptr) = xmlNodeListGetString( Xml_Doc, nodeset->nodeTab[0]->xmlChildrenNode, 1);
		    
				fprintf( stderr, "[%s] = [%s] found!\n", nodeset->nodeTab[0]->name, *Value_Ptr_Ptr);
		    }
		    }
		    
		    xmlXPathFreeObject(xml_xpathObj);
		    status = DRS_OK;
		}
	
/*
		xmlNodeSetPtr nodes = xml_xpathObj->nodesetval;
		xmlNodePtr cur;
		int size;
		int i;
    
		size = (nodes) ? nodes->nodeNr : 0;
    
		fprintf( stderr, "Result (%d nodes):\n", size);
		
		for( i = 0; i < size; ++i)
		{
		    assert( nodes->nodeTab[i]);
	
		    if(nodes->nodeTab[i]->type == XML_NAMESPACE_DECL)
		    {
			xmlNsPtr ns;
	    
			ns = (xmlNsPtr)nodes->nodeTab[i];
			cur = (xmlNodePtr)ns->next;
			
			if(cur->ns)
			{ 
			    fprintf( stderr, "= namespace \"%s\"=\"%s\" for node %s:%s\n", ns->prefix, ns->href, cur->ns->href, cur->name);
			}
			else
			{
			    fprintf( stderr, "= namespace \"%s\"=\"%s\" for node %s\n", ns->prefix, ns->href, cur->name);
			}
		    }
		    else
		    {
			if( nodes->nodeTab[i]->type == XML_ELEMENT_NODE)
			{
			    cur = nodes->nodeTab[i];
			
			    if(cur->ns)
			    { 
				fprintf( stderr, "= element node \"%s:%s\"\n", cur->ns->href, cur->name);
			    }
			    else
			    {
				fprintf( stderr, "= element node \"%s\"\n", cur->name);
			    }
			}
			else
			{
			    cur = nodes->nodeTab[i];
			    fprintf( stderr, "= node \"%s\": type %d\n", cur->name, cur->type);
			}
		    }
		}
*/		
/*   
	
    if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, "Kit number one", "This is the best drumkit!", "/tmp/toto.xml")) != DRS_OK)
    {
	return( status);
    }

    if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 1.1", "/tmp/instrument-1.1.wav", 1.01, NULL, 0)) != DRS_OK)
    {
	return( status);
    }
    
    if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 1.2", "/tmp/instrument-1.2.wav", 2.01, NULL, 0)) != DRS_OK)
    {
	return( status);
    }

    if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 1.3", "/tmp/instrument-1.3.wav", 0.02, NULL, 0)) != DRS_OK)
    {
	return( status);
    }

    
    if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, "Kit number two", "This is a good drumkit.", "/tmp/titi.xml")) != DRS_OK)
    {
	return( status);
    }
    
    if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 2.1", "/tmp/instrument-2.1.wav", 1.01, NULL, 0)) != DRS_OK)
    {
	return( status);
    }
    
    if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 2.2", "/tmp/instrument-2.2.wav", 2.01, NULL, 0)) != DRS_OK)
    {
	return( status);
    }

    if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 2.3", "/tmp/instrument-2.3.wav", 0.02, NULL, 0)) != DRS_OK)
    {
	return( status);
    }

    
    if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, "Kit number three", "This is not the the best drum kit...", "/tmp/tata.xml")) != DRS_OK)
    {
	return( status);
    }
*/
    





/*---------------------------------------------------------------------------------*/
/* DR_Kits_Dump                                                                    */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Kits_Dump( DRT_Base  *Base_Ptr)
{
    NDT_Status   nd_status;
    short        index;
    long         count = 0;

    
    fprintf( stderr, "DrumKit List:\n");

    if( ( nd_status = ND_DataStruct_Info_Print( stderr, Base_Ptr->Kit_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
    {
        printf( "ND_DataStruct_Info_Print() failed (%d) !\n", nd_status);
	return( DRS_KO);
    }

/*
    for( index = 0; index < Base_Ptr->Kit_DS_Ptr->Index_Nb; index++)
    {
	count = 0;
	fprintf( stderr, "Dump Index: (%d)\n", index);
	
	if( Base_Ptr-> Kit_DS_Ptr->Index_Tab[index].Node_Number == 0)
	{
	    fprintf( stderr, "  Empty list!\n");
	}
	else
	{
	    if( ( nd_status = ND_DataStruct_Traverse( Base_Ptr->Kit_DS_Ptr, (NDD_CMD_INDEX0_PRINT + index), stderr, &count)) != NDS_OK)
	    {
		printf( "Can't dump kits: ND_DataStruct_Traverse() failed (%d) !\n", nd_status);
		return( DRS_KO);
	    }
	}

	fprintf( stderr, "\n");
    }
*/
    if( ( nd_status = ND_DataStruct_Value_Print( stderr, Base_Ptr->Kit_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count)) != NDS_OK)
    {
	printf( "Can't dump kits: ND_DataStruct_Value_Print() failed (%d) !\n", nd_status);
	return( DRS_KO);
    }
    
    return( DRS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_Init                                                                         */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_Init( DRT_Base  *Base_Ptr)
{
    NDT_Status  nd_status;


    if( ( nd_status = ND_Library_Open( NDD_TRUE)) != NDS_OK)
    {
	fprintf( stderr, "Can't open node library (%d) !", nd_status);
	return( DRS_KO);
    }
    
    if( ( nd_status = ND_DataStruct_Open( &(Base_Ptr->Kit_DS_Ptr), DRD_KIT_DS_INDEX_NB, DRG_Kit_DS_Index_Tab_Initial, "Kit_Manager", DR_Kit_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK)
    {
	printf( "Kit_DS: ND_DataStruct_Open() failed (%d) !\n", nd_status);
	return( DRS_KO);
    }

    return( DRS_OK);
}





/*---------------------------------------------------------------------------------*/
/* DR_DeInit                                                                       */
/*---------------------------------------------------------------------------------*/

DRT_Status  DR_DeInit( DRT_Base  *Base_Ptr)
{
    NDT_Status  nd_status;

    
    if( ( nd_status = ND_DataStruct_Close( Base_Ptr->Kit_DS_Ptr)) != NDS_OK)
    {
	printf( "Can't close Kit_DS (%d)!\n", nd_status);
	return( DRS_KO);
    }

    if( ( nd_status = ND_Library_Close()) != NDS_OK)
    {
	fprintf( stderr, "Can't close node library (%d)!", nd_status);
	return( DRS_KO);
    }
    
    return( DRS_OK);
}
    





/*---------------------------------------------------------------------------------*/
/* main                                                                            */
/*---------------------------------------------------------------------------------*/

int  main( int  argc, char  **argv)
{
    DRT_Base    base;
    DRT_Status  status;

    
    if( ( status = DR_Init( &base)) != DRS_OK)
    {
	exit( -1);
    }

    if( ( status = DR_Kits_Load( &base)) != DRS_OK)
    {
	exit( -1);
    }

    printf( "hello world!\n");
    
    if( ( status = DR_Kits_Dump( &base)) != DRS_OK)
    {
	exit( -1);
    }

    if( ( status = DR_DeInit( &base)) != DRS_OK)
    {
	exit( -1);
    }

    exit( 0);
}