CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/pyKey.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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 3 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.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////
//
// pyKey   - the wrapper class around a plKey so that Python can handle it
//
//////////////////////////////////////////////////////////////////////

#include "pyKey.h"
#include "pnKeyedObject/plKey.h"
#include "plgDispatch.h"
#include "plPythonFileMod.h"
#include "pnMessage/plEnableMsg.h"
#include "hsResMgr.h"
#include "pySceneObject.h"
#include "pnSceneObject/plSceneObject.h"

pyKey::pyKey()
{
    fKey=nil;
#ifndef BUILDING_PYPLASMA
    fPyFileMod=nil;
    fNetForce=false;
#endif
}

pyKey::pyKey(plKey key)
{
    fKey = key;
#ifndef BUILDING_PYPLASMA
    fPyFileMod=nil;
    fNetForce=false;
#endif
}

#ifndef BUILDING_PYPLASMA
pyKey::pyKey(plKey key, plPythonFileMod* pymod)
{
    fKey = key;
    fPyFileMod=pymod;
    fNetForce=false;
}

void pyKey::SetNetForce(hsBool state)
{
    // set our flag
    fNetForce = state;
}

// send enable message to the plKey
void pyKey::Enable()
{
    IEnable(true);
}

    
// send disable message to the plKey
void pyKey::Disable()
{
    IEnable(false);
}
#endif

hsBool pyKey::operator==(const pyKey &key) const
{
    plKey ours = ((pyKey*)this)->getKey();
    plKey theirs = ((pyKey&)key).getKey();
    if ( ours == nil && theirs == nil )
        return true;
    else if ( ours != nil && theirs != nil )
        return (ours->GetUoid()==theirs->GetUoid());
    else
        return false;
}

#ifndef BUILDING_PYPLASMA
PyObject* pyKey::GetPySceneObject()
{
    plKey theKey = getKey();
    //if a modifier return the scene objects key
    plModifier* mod = plModifier::ConvertNoRef(theKey->ObjectIsLoaded());
    if (mod)
    {
        if(mod->GetNumTargets()>0)
        {
            return pySceneObject::New(mod->GetTarget(0)->GetKey());
        }
        else return nil;
    }
    // create pySceneObject that will be managed by Python
    return pySceneObject::New(getKey());
}

// send disable message to the plKey
void pyKey::IEnable(hsBool state)
{
    // create message
    plEnableMsg* pMsg = TRACKED_NEW plEnableMsg;
    if (fNetForce )
    {
        // set the network propagate flag to make sure it gets to the other clients
        pMsg->SetBCastFlag(plMessage::kNetPropagate);
        pMsg->SetBCastFlag(plMessage::kNetForce);
    }
    pMsg->AddReceiver(fKey);
    // which way are we doin' it?
    if ( state )
        pMsg->SetCmd(plEnableMsg::kEnable);
    else
        pMsg->SetCmd(plEnableMsg::kDisable);
    plgDispatch::MsgSend( pMsg );   // whoosh... off it goes
}


// if this is a modifier then get the (first) object its attached to
PyObject* pyKey::GetParentObject()
{
    if (fKey)
    {
        // see if this a modifier that is loaded
        plModifier* mod = plModifier::ConvertNoRef(fKey->ObjectIsLoaded());
        if (mod)
        {
            if ( mod->GetNumTargets() > 0 )
                return pyKey::New(mod->GetTarget(0)->GetKey());
        }
    }
    return nil;
}


// special functions when the plKey is a pointer to the PythonModifier
//
// Was the last plNotifyMsg a locally sent?
hsBool pyKey::WasLocalNotify()
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        return fPyFileMod->WasLocalNotify();
    // otherwise... just say it is local
    return true;
}

// Is python file mod attached to clone
hsBool pyKey::IsAttachedToClone()
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        return fPyFileMod->AmIAttachedToClone();
    // otherwise return nope
    return false;
}

plPipeline* pyKey::GetPipeline()
{
    if ( fPyFileMod )
        return fPyFileMod->GetPipeline();
    return nil;
}

// get the notify list count
Int32 pyKey::NotifyListCount()
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        return fPyFileMod->NotifyListCount();
    // otherwise... just say notify list receivers
    return 0;
}

// get a notify list item
plKey pyKey::GetNotifyListItem(Int32 i)
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        return fPyFileMod->GetNotifyListItem(i);
    // otherwise... just say it is local
    return nil;
}


// Set the dirty state on the PythonModifier
void pyKey::DirtySynchState(const char* SDLStateName, UInt32 sendFlags)
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        fPyFileMod->DirtySynchState(SDLStateName, sendFlags);
}


// register for control key events with the pythonfile modifier
void pyKey::EnableControlKeyEvents()
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        // if so, then pass on the command request
        fPyFileMod->EnableControlKeyEvents();
}

// unregister for control key events with the pythonfile modifier
void pyKey::DisableControlKeyEvents()
{
    // see if we have a PythonFileModifier pointer
    if ( fPyFileMod )
        // if so, then pass on the command request
        fPyFileMod->DisableControlKeyEvents();
}
#endif // BUILDING_PYPLASMA