src/Plugin.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.
-----------------------------------------------------------------------------
*/

/*
 TUsb respiration belt library
 First version : august 2011
 Author : Aymeric Suteau
*/

// Include Header File
#include "Plugin.h"

cbmachine ww;
HWND HScol = NULL;      

int OBJTUSBSCOL;

//===== CB Connected ===
int SCOL_TUSB_CONNECTED_CB      = 0;
int TUSB_CONNECTED_CB;

//===== CB Disconnected ===
int SCOL_TUSB_DISCONNECTED_CB   = 1;
int TUSB_DISCONNECTED_CB;

//===== CB New data ===
int SCOL_TUSB_NEW_DATA_CB       = 2;
int TUSB_NEW_DATA_CB;

//===== CB Battery level ===
int SCOL_TUSB_BATTERY_LEVEL_CB  = 3;
int TUSB_BATTERY_LEVEL_CB;



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

        // Safely dispose of "RespirationBeltObj" pointer
        SAFE_DELETE(RespirationBeltObj);
  MMechostr(MSKDEBUG, "destroyTUsbObj ...SAFE_DELETE ok\n");

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

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


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

        // Declare local variables
        int k = 0;

  // Get and test Channel
        int channel = MMget(m, 0);
        if (channel == NIL) 
  { 
                MMechostr(MSKDEBUG, "Channel NIL\n");     // Display Warning in Scol Console
                MMpull(m);
                MMpush(m, NIL);
                return 0;
        }

        // Create RespirationBelt instance
        RespirationBelt* respirationBelt = new RespirationBelt();

        // Allocate a block in the stack for a table of RespirationBelt objects
        int respirationBeltTab = MMmalloc(m, 1, TYPETAB);
        if (respirationBeltTab == NIL)
  {
                MMechostr(0, "_CRTUsbDevice ...MMmalloc failed\n");
                SAFE_DELETE(respirationBelt); 
                MMpull(m);
                return MMpush(m, NIL);
        }
        MMstore(m, respirationBeltTab, 0, (int)respirationBelt);
        MMpush(m, PTOM(respirationBeltTab));

        // Create a new TUsb respiration RespirationBelt object
        k = OBJcreate(m, OBJTUSBSCOL, (int)respirationBelt, -1, -1);

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

        // Return RespirationBelt object
        return k;
}


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

        // Get the table of RespirationBelt objects into the stack (without pulling it)
        int respirationBeltTab = MMget(m, 0);
        if (respirationBeltTab == NIL)
  {
                MMechostr(0, "_DSTUsbDevice ...ObjTUsb NIL\n");
                MMset(m, 0, NIL);
                return 0;
        }

        // Destroy RespirationBelt object according to its type and magma object, and reinitialize the stack
  OBJdelTM(m, OBJTUSBSCOL, respirationBeltTab);
        MMset(m, 0, ITOM(0));

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

        return 0;
}


int _CBTUsbConnected(mmachine m)
{
  return (OBJaddreflex(m, OBJTUSBSCOL, SCOL_TUSB_CONNECTED_CB));
}

int getTUsbConnectedCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
        RespirationBelt* RespirationBeltObj = (RespirationBelt*) id;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJTUSBSCOL, (int)RespirationBeltObj, SCOL_TUSB_CONNECTED_CB))
  {
    MMechostr(0, "getTUsbConnectedCb -> OBJbeginreflex failed.\n");
                return 0;
  }
        return (OBJcallreflex(m, 0));
}


int _CBTUsbDisconnected(mmachine m)
{
  return (OBJaddreflex(m, OBJTUSBSCOL, SCOL_TUSB_DISCONNECTED_CB));
}

int getTUsbDisconnectedCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
        RespirationBelt* RespirationBeltObj = (RespirationBelt*) id;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJTUSBSCOL, (int)RespirationBeltObj, SCOL_TUSB_DISCONNECTED_CB))
  {
    MMechostr(0, "getTUsbDisconnectedCb -> OBJbeginreflex failed.\n");
                return 0;
  }
        return (OBJcallreflex(m, 0));
}


int _CBTUsbNewData(mmachine m)
{
  return (OBJaddreflex(m, OBJTUSBSCOL, SCOL_TUSB_NEW_DATA_CB));
}

int getTUsbNewDataCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0, nb = 0;
  BeltData* beltData = (BeltData*) param;
        RespirationBelt* RespirationBeltObj = (RespirationBelt*) id;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJTUSBSCOL, (int)RespirationBeltObj, SCOL_TUSB_NEW_DATA_CB))
  {
    SAFE_DELETE(beltData);
    MMechostr(0, "getTUsbNewDataCb -> OBJbeginreflex failed.\n");
                return 0;
  }

  // Browse new data
  std::list<float> lData = beltData->GetBeltData();
  std::list<float>::iterator itData = lData.begin();
  while (itData != lData.end())
  {
    if (MMpush(m, FTOM(*itData)))
    {
      SAFE_DELETE(beltData);
      return MERRMEM;
    }
    itData++;
    nb++;
  }

  if (MMpush(m, NIL))
  {
    SAFE_DELETE(beltData);
    return MERRMEM;
  }

  for (int i = 0; i < nb; i++)
        {
    if (MMpush(m, 2*2))
    {
      SAFE_DELETE(beltData);
      return MERRMEM;
    }
                if (k = MBdeftab(m))
    {
      SAFE_DELETE(beltData);
      return k;
    }
        }

  // Call reflex previously defined
        k = OBJcallreflex(m, 1);
  SAFE_DELETE(beltData);
  return k;
}


int _CBTUsbBatteryLevel(mmachine m)
{
  return (OBJaddreflex(m, OBJTUSBSCOL, SCOL_TUSB_BATTERY_LEVEL_CB));
}

int getTUsbBatteryLevelCb(mmachine m, HWND h, unsigned msg, UINT id, LONG param, int *ret)
{
        int k = 0;
        RespirationBelt* RespirationBeltObj = (RespirationBelt*) id;

        // OBJbeginreflex(mmachine, objecttype, objectptr, cbtype)
        if (OBJbeginreflex(m, OBJTUSBSCOL, (int)RespirationBeltObj, SCOL_TUSB_BATTERY_LEVEL_CB))
  {
    MMechostr(0, "getTUsbBatteryLevelCb -> OBJbeginreflex failed.\n");
                return 0;
  }

  // Push battery level into the stack
  MMpush(m, FTOM(param));
        return (OBJcallreflex(m, 1));
}




#define NbTplPKG 7


char *TplName[NbTplPKG] =
{
        "ObjTUsb",
  "_CRTUsbDevice",
        "_DSTUsbDevice",
  "_CBTUsbConnected",
  "_CBTUsbDisconnected",
  "_CBTUsbNewData",
  "_CBTUsbBatteryLevel"
};


int (*TplFunc[NbTplPKG])(mmachine m)=
{
        NULL,                                                                           // ObjTUsb
  _CRTUsbDevice,                                  // _CRTUsbDevice
        _DSTUsbDevice,                            // _DSTUsbDevice
  _CBTUsbConnected,       // _CBTUsbConnected
  _CBTUsbDisconnected,    // _CBTUsbDisconnected
  _CBTUsbNewData,         // _CBTUsbNewData
  _CBTUsbBatteryLevel     // _CBTUsbBatteryLevel
};


int TplNArg[NbTplPKG]=
{
        TYPTYPE,    // ObjTUsb
  1,                                    // _CRTUsbDevice
        1,                                      // _DSTUsbDevice
  3,          // _CBTUsbConnected
  3,          // _CBTUsbDisconnected
  3,          // _CBTUsbNewData
  3           // _CBTUsbBatteryLevel
};


char* TplType[NbTplPKG]=
{
        NULL,                                                                                                                                                                         // ObjTUsb
  "fun [Chn] ObjTUsb",                                                                                            // _CRTUsbDevice
        "fun [ObjTUsb] I",                                                                                                        // _DSTUsbDevice
  "fun [ObjTUsb fun [ObjTUsb u0] u1 u0] ObjTUsb",             // _CBTUsbConnected
  "fun [ObjTUsb fun [ObjTUsb u0] u1 u0] ObjTUsb",             // _CBTUsbDisconnected
  "fun [ObjTUsb fun [ObjTUsb u0 [F r1]] u1 u0] ObjTUsb",    // _CBTUsbNewData
  "fun [ObjTUsb fun [ObjTUsb u0 F] u1 u0] ObjTUsb"          // _CBTUsbBatteryLevel
};


// Everything inside _cond and _endcond is ignored by doxygen

int LoadTUsb(mmachine m)
{
  // Return variable for PKhardpak function
        int k;

        // Declare a new type of object ("OBJTUSBSCOL")
        OBJTUSBSCOL = OBJregister(4, 1, destroyTUsbObj, "OBJTUSBSCOL");

  // Get new user events and associate these events with a callback
  TUSB_CONNECTED_CB = OBJgetUserEvent();
  OBJdefEvent(TUSB_CONNECTED_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getTUsbConnectedCb);

  TUSB_DISCONNECTED_CB = OBJgetUserEvent();
  OBJdefEvent(TUSB_DISCONNECTED_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getTUsbDisconnectedCb);

  TUSB_NEW_DATA_CB = OBJgetUserEvent();
  OBJdefEvent(TUSB_NEW_DATA_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getTUsbNewDataCb);

  TUSB_BATTERY_LEVEL_CB = OBJgetUserEvent();
  OBJdefEvent(TUSB_BATTERY_LEVEL_CB, (int (__cdecl *)(struct Mmachine *, int, unsigned int, int, int, int *))getTUsbBatteryLevelCb);

        // Load package
        k = PKhardpak(m, "FusionEngine", NbTplPKG, TplName, TplFunc, TplNArg, TplType);

  // Initialize COM library
  if (FAILED(::CoInitialize(NULL)))     
    return 0;

        return k;
}


extern "C" __declspec (dllexport) int ScolLoadPlugin(mmachine m, cbmachine w) 
{
        SCOLinitplugin(w);

        // Get Scol window handle (for message callback)
        HScol = (HWND)SCgetExtra("hscol");      
        LoadTUsb(m);
        return 0;
}


extern "C" __declspec (dllexport) int ScolUnloadPlugin() 
{
  // Uninitialize COM library
  ::CoUninitialize();

        return 0;
}