SO3Engine/SCOLPack/SCOLLog.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.
-----------------------------------------------------------------------------
*/

/*
 SO3Engine : Wrapper Ogre for SCOL
 First version : nov 2008
*/


#include        "SO3SCOL.h"

// Renderer includes
#include "../SO3Renderer/SO3Root.h"
#include "../SO3Renderer/SO3LogListener.h"

int SO3LOGS;
int SO3_LOGS_MSG;


class ScolLogEventsListener : public SLogListener
{
public:
protected:
private:
  WindowHandle windowHandleScol;

public:
  ScolLogEventsListener(WindowHandle windowHandle)
  {
    windowHandleScol = windowHandle;
  };

  virtual void messageLogged(const Ogre::String& message)
  {
    char* cmess = (char*)malloc(sizeof(char*) * (message.length() + 1));
    std::strcpy(cmess, message.c_str());

    PostMessage(windowHandleScol, SO3_LOGS_MSG, (int)SRoot::getSingletonPtr(), (LPARAM)cmess);
  }

protected:
private:
  ScolLogEventsListener()
  {
  };
};


ScolLogEventsListener* scolLogEventsListener = 0;


int     destroyLogs(mmachine m, int handle, int obj)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG,"destroyLogs \n");
#endif
  
  SRoot::getSingleton().SetLogEnable(false);

        MMstore(m, MTOP(obj), 0, NULL);
        return 0;
}


int getLogCallback(mmachine m, WindowHandle h,unsigned msg,UINT id,LONG param,int *ret)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "getLogCallback\n");
#endif

        int k = 0;
  int obj = 0;
  
  if(SRoot::getSingletonPtr() == 0)
    return -1;

  // equal to OBJbeginreflex
        // is there a callback assigned to the object?
  obj = OBJfindTH(m, SO3LOGS, id);
  if (obj == NIL)
    return -1;
  
        if (MMfetch(m, obj, OFFOBJREF0+SO3_LOGS_CB*2)==NIL) 
    return -1;

  //equal to OBJpreparereflex but replace the object
  //set the current channel
  MMsetglobal(m, OFFSCCUR, MMfetch(m, obj, OFFOBJCHN));
  if (MMpush(m, MMgetglobal(m, OFFSCCUR))) return MERRMEM;

  //push the callback ptr
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0+SO3_LOGS_CB*2))) return MERRMEM;

  // replace the object by the log message
        if (Mpushstrbloc(m, (char*)param)) return MERRMEM;

  //push the user parameter
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0+SO3_LOGS_CB*2+1))) return MERRMEM;
  
  free((char*)param);
        return OBJcallreflex(m, 0);
}


int SO3CbLogs (mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3CbSceneLog\n");
#endif

  int flag = MMpull(m);
  int p = MMpull(m);
  int reflex = MMpull(m);
  int   chan = MMget(m, 0);

  if(chan==NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  if (SRoot::getSingletonPtr() == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
        
  int n = OBJfindTH(m, SO3LOGS, (int)(SRoot::getSingletonPtr()));
  if(n!=NIL)
  {
    n = MMfetch(m, n, OFFOBJMAG);
    //remove channel
    MMpull(m);
    MMpush(m, n);
  }
  else
  {
          int so3logobj = MMmalloc(m, 1, TYPETAB);
    if (so3logobj==NIL)
    {
      return MERRMEM;
    }

          MMstore(m, so3logobj, 0, (int)SRoot::getSingletonPtr());
          MMpush(m, PTOM(so3logobj));
          OBJcreate(m, SO3LOGS, (int)SRoot::getSingletonPtr(), NIL, NIL);
  }
  

  Ogre::LoggingLevel logFlag = Ogre::LL_NORMAL;
  if (flag != NIL)
    logFlag = (Ogre::LoggingLevel)MTOI(flag);

  SRoot::getSingleton().SetLogMask(logFlag);
  SRoot::getSingleton().SetLogEnable(reflex == NIL ? false : true);
  
  MMpush(m, reflex);
  MMpush(m, p);

        OBJaddreflex (m, SO3LOGS, SO3_LOGS_CB);

  MMset(m, 0, ITOM(1));

  return 0;
}


#define NBLOGSPKG 2


char* LOGSname[NBLOGSPKG]=
{
  "SO3Logs",
  "SO3CbLogs"
};


int (*LOGSFunc[NBLOGSPKG])(mmachine m)=
{
  NULL,
  SO3CbLogs

};


int LOGSnarg [NBLOGSPKG]=
{
  TYPTYPE,
  4                                          //SO3CbLogs
 
};


char* LOGSType[NBLOGSPKG]=
{
  NULL,
  "fun [Chn fun [S u0] u1 u0 I] I"           //SO3CbLogs
 
};


int SCOLloadLogs(mmachine m,cbmachine w)
{
  scolLogEventsListener = new ScolLogEventsListener(SRoot::getSingleton().GetRootWindowHandle());
  SRoot::getSingleton().AddLogListener(scolLogEventsListener);

  SO3LOGS = OBJregister(1, 1, destroyLogs, "SO3_LOGS");

  SO3_LOGS_MSG = OBJgetUserEvent();
  OBJdefEvent(SO3_LOGS_MSG, (int (__cdecl *)(struct Mmachine *,int,unsigned int,int,int,int *))getLogCallback);
        return PKhardpak(m, "SO3Logs", NBLOGSPKG, LOGSname, LOGSFunc, LOGSnarg, LOGSType);
}


int SCOLfreeLogs()
{
  SRoot::getSingleton().RemoveLogListener(scolLogEventsListener);
  SAFE_DELETE(scolLogEventsListener);
        return 0;
}

---