sources/template.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2010 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include <scol.h>
#include "Bloc.h"

HWND HScol = NULL;

cbmachine ww;

int OBJBLOCSCOL;

int SCOL_BLOC_NEW_DATA_CB=0;

int BLOC_NEW_DATA_CB;



typedef int BlocObj;


int _GETblocValue(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_GetWiiExtensionType\n");
#endif
  // Get bloc table from the stack, then transform it
        int blocTable = MTOP( MMget(m,0) ) ;
        if ( blocTable == NIL ) { MMset(m,0,NIL) ; return 0 ; }

  // cast this bloc in a Bloc object
        Bloc* bloc = (Bloc*)MMfetch(m, blocTable, 0) ;
        if( !bloc ) { MMset(m,0,NIL) ; return 0 ; }

  // put the return of the function call in the stack 
        MMset(m,0,ITOM(bloc->getValue()));

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif

        return 0;
}


int _SETblocValue(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_SETblocValue\n");
#endif
  // Get param
        int value = MTOI( MMpull(m) ) ;

        // Get Bloc table
  int blocTable = MTOP( MMget(m,0) ) ;
        if ( blocTable == NIL ) { MMset(m,0,-1) ; return 0 ; }

  // Cast the content of bloc table to Bloc*
        Bloc* bloc = (Bloc*)MMfetch(m, blocTable, 0) ;
 
        bloc->setValue(value);

        MMset(m,0,0);
        
        // send the change data callback message to scol, use PostMessage instead if you need to poll the message
        SendMessage( HScol, BLOC_NEW_DATA_CB,(int)bloc,(LPARAM)NULL);

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif

        return 0;
}


int _GETblocName(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_GetWiiExtensionType\n");
#endif
  // Get bloc table in the stack, then transform it in system pointer
        int blocTable = MTOP( MMget(m,0) ) ;
        if ( blocTable == NIL ) { MMset(m,0,NIL) ; return 0 ; }

  // cast this bloc in a Bloc object
        Bloc* bloc = (Bloc*)MMfetch(m, blocTable, 0) ;
        if( !bloc ) { MMset(m,0,NIL) ; return 0 ; }

        // remove param from stack
        MMpull(m);

        // put in the stack the return of the function call  
        Mpushstrbloc(m, bloc->getName());

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif

        return 0;
}


int _SETblocName(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_SETblocValue\n");
#endif
  // Get param
        int name = MTOP( MMpull(m) ) ;

        // Get Bloc table
  int blocTable = MTOP( MMget(m,0) ) ;
        if ( blocTable == NIL ) { MMset(m,0,-1) ; return 0 ; }

  // Cast the content of bloc table to Bloc*
        Bloc* bloc = (Bloc*)MMfetch(m, blocTable, 0) ;

        char * sname = MMstartstr(m, name);
 
        bloc->setName(sname);

        MMset(m,0,0);

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif

        return 0;
}


int destroyBlocObj(mmachine m, int handsys, int blocTab) {
        // Read the first element of a TAB element (table of objects)
        Bloc* bloc = (Bloc*) MMfetch(m, MTOP(blocTab), 0);
        if (bloc == NULL) {
                // Write the first element in the stack, without pulling it
                MMset(m, 0, NIL); 
                return 0;
        }

        // Safely dispose of "Bloc" pointer
        SAFE_DELETE(bloc);

        // Write the first element of a TAB element
        MMstore(m, MTOP(blocTab), 0, NULL);

        // Display debug message
        MMechostr(MSKDEBUG,"Bloc object destroyed.\n");
        return 0;
}


int _CRbloc(mmachine m) {
        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"_CRbloc\n");
        #endif

        // Declare local variables
        int k = 0;

        // Get the channel without pulling it (first element in the stack)
        int channel = MMget(m, 0);

        // Test the channel
        if (channel == NIL) { 
                MMechostr(MSKDEBUG, "Channel NIL\n");
                MMpull(m);                                                // Pull the channel                                                                                                   
                MMpush(m, NIL);                                 // Push NIL on the stack
                return 0;
        }

        // Create bloc instance
        Bloc * bloc = new Bloc();
  
  if (bloc == NULL) {
                MMechostr(MSKDEBUG, "_CRbloc ...initialization failed\n");
                SAFE_DELETE(bloc) ;
                MMpull(m);                                                              // Pull the channel
                MMpush(m, NIL);                                                 // Push NIL on the stack
                return 0;
        }
        MMechostr(MSKDEBUG,"_CRbloc ...initialization successful\n");

        // Allocate a space in the stack for a table of bloc objects
        int blocTab = MMmalloc(m, 1, TYPETAB);
        if (blocTab == NIL) {
                MMechostr(MSKDEBUG,"_CRbloc ...MMmalloc failed\n");
                SAFE_DELETE(bloc); 
                MMpull(m);                                                              // Pull the channel
                return MMpush(m, NIL);                                  // Push NIL on the stack
        }
        MMechostr(MSKDEBUG,"_CRbloc ...MMmalloc successful\n");

        // Push the table of bloc objects into the stack
        MMstore(m, blocTab, 0, (int)bloc);
        MMpush(m, PTOM(blocTab));

        // Create a new scol bloc object
        k = OBJcreate(m, OBJBLOCSCOL, (int)bloc, NULL, NULL);
        MMechostr(MSKDEBUG,"_CRbloc ...object creation successful\n");

        #ifdef  _SCOL_DEBUG_
                MMechostr(MSKDEBUG,"ok\n");
        #endif

        // Return bloc object
        return k;
}


int _DSbloc(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_DSbloc\n");
#endif
        
        int bloc = MTOP( MMget(m,0) );
        if ( bloc == NIL ) { MMset(m,0,NIL); return 0; }
        
        OBJdelTM( m, OBJBLOCSCOL, PTOM(bloc) );
        MMset(m,0,0);   

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif
        return 0;
}


int _CBblocChangeValue(mmachine m) {
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBblocChangeValue ...adding reflex\n");
        return OBJaddreflex(m, OBJBLOCSCOL, SCOL_BLOC_NEW_DATA_CB);
}


int getBlocNewData(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret) {
        int k = 0;
  
        // Cast id parameter to BlocObj type
        Bloc * bloc = (Bloc*) id;

        // Use : OBJbeginreflex(mmachine, type of object, ptr object, callback type)
        if (OBJbeginreflex(m, OBJBLOCSCOL, (int)bloc, SCOL_BLOC_NEW_DATA_CB)) {
                MMechostr(MSKDEBUG,"Bloc not found\n");
                return 0;
        }
  
        // Retrieve current bloc value, and set it as 3rd parameter of the callback
        MMpush(m, ITOM(bloc->getValue()));
  // Retrieve current bloc name, and set it as 4th parameter of the callback
  Mpushstrbloc(m, bloc->getName());

        // Call reflex previously defined
        k = OBJcallreflex(m, 2 /*nb param after obj and u0*/);
        return k;
}



#define NbTplPKG        8


char    *TplName[NbTplPKG] =
{       
        "ObjBloc",
        "_CRbloc",
        "_DSbloc",
        "_GETblocValue",
        "_GETblocName",
        "_SETblocName",
        "_SETblocValue",
        "_CBblocChangeValue"
};


int (*TplFunc[NbTplPKG])(mmachine m)=
{
  NULL, 
  _CRbloc,
        _DSbloc,
        _GETblocValue,
        _GETblocName,
        _SETblocName,
        _SETblocValue,
        _CBblocChangeValue
};


int TplNArg[NbTplPKG]=
{
  TYPTYPE,      
        1,
        1,
  1,
        1,
        2,
        2,
        3
};


char* TplType[NbTplPKG]=
{
        NULL,
        "fun [Chn] ObjBloc",                                                               // _CRbloc
        "fun [ObjBloc] I",                                                             // _DSbloc
        "fun [ObjBloc] I",                                 // _GETblocValue
        "fun [ObjBloc] S",                                 // _GETblocName
        "fun [ObjBloc S] I",                               // _SETblocName
        "fun [ObjBloc I] I",                               // _SETblocValue
        "fun [ObjBloc fun [ObjBloc u0 I S] u1 u0] ObjBloc" //_CBblocChangeValue
};


int LoadBloc(mmachine m) {
        int k;

        // Declare a new type of object ("OBJBLOCSCOL")
        OBJBLOCSCOL = OBJregister(1 /*nb of callback*/, /* deleted from parent */ 1, destroyBlocObj, "OBJBLOCSCOL");

        // ----- Define callbacks
        // Get a new user event
        BLOC_NEW_DATA_CB = OBJgetUserEvent();

        // Associate this event with a callback 
        OBJdefEvent(BLOC_NEW_DATA_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getBlocNewData);
  
        // Load package
        k = PKhardpak(m, "TemplateEngine", NbTplPKG, TplName, TplFunc, TplNArg, TplType);
        return k;
}


// Everything inside _cond and _endcond is ignored by doxygen

extern "C" __declspec (dllexport) 
int SCOLloadTemplate(mmachine m, cbmachine w)
{
        SCOLinitplugin(w);
        // Get Scol window handle (for message callback)
        HScol = (HWND)SCgetExtra("hscol");

        // Display debug message
        MMechostr(MSKDEBUG,"Loading Template DLL ...\n");       
        return 0; 
}

extern "C" __declspec (dllexport)
int SCOLfreeTemplate()
{
        // Display debug messages
        MMechostr(MSKDEBUG, "Template DLL CLOSED...\n\n" );
        return 0;
}

---