mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-11-14 11:19:03 +00:00
765 lines
22 KiB
C++
765 lines
22 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
#include "stdpch.h"
|
|
#include "nel/gui/interface_expr.h"
|
|
#include "nel/gui/interface_expr_node.h"
|
|
#include "nel/gui/reflect.h"
|
|
#include "nel/gui/db_manager.h"
|
|
#include "nel/misc/cdb_branch.h"
|
|
#include "nel/gui/action_handler.h"
|
|
#include "nel/gui/interface_link.h"
|
|
#include "nel/gui/interface_element.h"
|
|
#include "nel/gui/interface_group.h"
|
|
#include "nel/gui/widget_manager.h"
|
|
#include "nel/misc/algo.h"
|
|
|
|
#include <iterator>
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
|
|
namespace NLGUI
|
|
{
|
|
|
|
/////////////
|
|
// GLOBALS //
|
|
/////////////
|
|
|
|
CInterfaceLink::TLinkList CInterfaceLink::_LinkList;
|
|
CInterfaceLink::TLinkVect CInterfaceLink::_LinksWithNoTarget;
|
|
//
|
|
CInterfaceLink *CInterfaceLink::_FirstTriggeredLink[2] = { NULL, NULL };
|
|
CInterfaceLink *CInterfaceLink::_LastTriggeredLink[2] = { NULL, NULL };
|
|
CInterfaceLink *CInterfaceLink::_CurrUpdatedLink = NULL;
|
|
CInterfaceLink *CInterfaceLink::_NextUpdatedLink = NULL;
|
|
uint CInterfaceLink::_CurrentTriggeredLinkList = 0;
|
|
|
|
bool CInterfaceLink::_UpdateAllLinks = false;
|
|
|
|
|
|
///////////////
|
|
// FUNCTIONS //
|
|
///////////////
|
|
|
|
/** Tool fct : affect a value to a reflected property of an interface element.
|
|
*/
|
|
static bool affect(const CInterfaceExprValue &value, CInterfaceElement &destElem, const CReflectedProperty &property)
|
|
{
|
|
|
|
CInterfaceExprValue valueToAffect = value;
|
|
switch(property.Type)
|
|
{
|
|
case CReflectedProperty::Boolean:
|
|
if (valueToAffect.toBool())
|
|
{
|
|
(destElem.*(property.SetMethod.SetBool))(valueToAffect.getBool());
|
|
}
|
|
else
|
|
{
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
case CReflectedProperty::SInt32:
|
|
if (valueToAffect.toInteger())
|
|
{
|
|
(destElem.*(property.SetMethod.SetSInt32))((sint32) valueToAffect.getInteger());
|
|
}
|
|
else
|
|
{
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
case CReflectedProperty::Float:
|
|
if (valueToAffect.toDouble())
|
|
{
|
|
(destElem.*(property.SetMethod.SetFloat))((float) valueToAffect.getDouble());
|
|
}
|
|
else
|
|
{
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
case CReflectedProperty::String:
|
|
if (valueToAffect.toString())
|
|
{
|
|
(destElem.*(property.SetMethod.SetString))(valueToAffect.getString());
|
|
}
|
|
else
|
|
{
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
case CReflectedProperty::UCString:
|
|
if (valueToAffect.toString())
|
|
{
|
|
(destElem.*(property.SetMethod.SetUCString))(valueToAffect.getUCString());
|
|
}
|
|
else
|
|
{
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
case CReflectedProperty::RGBA:
|
|
if (valueToAffect.toRGBA())
|
|
{
|
|
(destElem.*(property.SetMethod.SetRGBA))(valueToAffect.getRGBA());
|
|
}
|
|
else
|
|
{
|
|
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
CInterfaceLink::CInterfaceLinkUpdater::CInterfaceLinkUpdater()
|
|
{
|
|
NLGUI::CDBManager::getInstance()->addFlushObserver( this );
|
|
}
|
|
|
|
CInterfaceLink::CInterfaceLinkUpdater::~CInterfaceLinkUpdater()
|
|
{
|
|
}
|
|
|
|
void CInterfaceLink::CInterfaceLinkUpdater::onObserverCallFlush()
|
|
{
|
|
CInterfaceLink::updateTrigeredLinks();
|
|
}
|
|
|
|
/////////////
|
|
// MEMBERS //
|
|
/////////////
|
|
|
|
//===========================================================
|
|
CInterfaceLink::CInterfaceLink() : _On(true)
|
|
{
|
|
// add an entry in the links list
|
|
_LinkList.push_front(this);
|
|
_ListEntry = _LinkList.begin();
|
|
_PrevTriggeredLink[0] = _PrevTriggeredLink[1] = NULL;
|
|
_NextTriggeredLink[0] = _NextTriggeredLink[1] = NULL;
|
|
_Triggered[0] = _Triggered[1] = false;
|
|
_ParseTree = NULL;
|
|
_AHCondParsed = NULL;
|
|
}
|
|
|
|
//===========================================================
|
|
CInterfaceLink::~CInterfaceLink()
|
|
{
|
|
if (this == _CurrUpdatedLink)
|
|
{
|
|
_CurrUpdatedLink = NULL;
|
|
}
|
|
if (this == _NextUpdatedLink)
|
|
{
|
|
_NextUpdatedLink = _NextUpdatedLink->_NextTriggeredLink[1 - _CurrentTriggeredLinkList];
|
|
}
|
|
// unlink observer from both update lists
|
|
unlinkFromTriggerList(0);
|
|
unlinkFromTriggerList(1);
|
|
|
|
removeObservers(_ObservedNodes);
|
|
// removes from the link list
|
|
_LinkList.erase(_ListEntry);
|
|
|
|
delete _ParseTree;
|
|
_ParseTree = NULL;
|
|
delete _AHCondParsed;
|
|
_AHCondParsed = NULL;
|
|
}
|
|
|
|
//===========================================================
|
|
bool CInterfaceLink::init(const std::vector<CTargetInfo> &targets, const std::vector<CCDBTargetInfo> &cdbTargets, const std::string &expr, const std::string &actionHandler, const std::string &ahParams, const std::string &ahCond, CInterfaceGroup *parentGroup)
|
|
{
|
|
CInterfaceExprValue result;
|
|
// Build the parse tree
|
|
nlassert(!_ParseTree);
|
|
_ParseTree = CInterfaceExpr::buildExprTree(expr);
|
|
if (!_ParseTree)
|
|
{
|
|
// wrong expression : release the link
|
|
nlwarning("CInterfaceLink::init : can't parse expression %s", expr.c_str());
|
|
_LinksWithNoTarget.push_back(TLinkSmartPtr(this));
|
|
return false;
|
|
}
|
|
// Examine the expression, to see which database nodes it depends on
|
|
_ParseTree->getDepends(_ObservedNodes);
|
|
// must keep observerd node sorted (for std::set_xx ops)
|
|
std::sort(_ObservedNodes.begin(), _ObservedNodes.end());
|
|
if (!targets.empty())
|
|
{
|
|
// retrieve properties from the element
|
|
_Targets.resize(targets.size());
|
|
for (uint k = 0; k < targets.size(); ++k)
|
|
{
|
|
CInterfaceElement *elem = targets[k].Elem;
|
|
if (!elem)
|
|
{
|
|
nlwarning("<CInterfaceLink::init> : Element %d is NULL", k);
|
|
_Targets[k]._InterfaceElement = NULL;
|
|
continue;
|
|
}
|
|
_Targets[k]._Property = elem->getReflectedProperty(targets[k].PropertyName);
|
|
if (!_Targets[k]._Property)
|
|
{
|
|
nlwarning("<CInterfaceLink::init> : Can't retrieve property %s for element %d.", targets[k].PropertyName.c_str(), k);
|
|
_Targets[k]._InterfaceElement = NULL;
|
|
continue;
|
|
}
|
|
_Targets[k]._InterfaceElement = elem;
|
|
elem->addLink(this);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// There are no target for this link, so, put in a dedicated list to ensure that the link will be destroyed at exit
|
|
_LinksWithNoTarget.push_back(TLinkSmartPtr(this));
|
|
}
|
|
_CDBTargets = cdbTargets;
|
|
|
|
// create observers
|
|
createObservers(_ObservedNodes);
|
|
_Expr = expr;
|
|
//
|
|
_ActionHandler = actionHandler;
|
|
_AHParams = ahParams;
|
|
nlassert(!_AHCondParsed);
|
|
_AHCond = ahCond;
|
|
if (!ahCond.empty())
|
|
{
|
|
_AHCondParsed = CInterfaceExpr::buildExprTree(ahCond);
|
|
}
|
|
_AHParent = parentGroup;
|
|
return true;
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::uninit()
|
|
{
|
|
for (uint32 i = 0; i < _LinksWithNoTarget.size(); i++)
|
|
{
|
|
CInterfaceLink *pLink = _LinksWithNoTarget[i];
|
|
if (pLink == this)
|
|
{
|
|
_LinksWithNoTarget.erase(_LinksWithNoTarget.begin()+i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::update(ICDBNode * /* node */)
|
|
{
|
|
// mark link as triggered
|
|
linkInTriggerList(_CurrentTriggeredLinkList);
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::createObservers(const TNodeVect &nodes)
|
|
{
|
|
for(std::vector<ICDBNode *>::const_iterator it = nodes.begin(); it != nodes.end(); ++it)
|
|
{
|
|
if ((*it)->isLeaf())
|
|
{
|
|
ICDBNode::CTextId textId;
|
|
(*it)->addObserver(this, textId);
|
|
}
|
|
else
|
|
{
|
|
CCDBNodeBranch *br = static_cast<CCDBNodeBranch *>(*it);
|
|
NLGUI::CDBManager::getInstance()->addBranchObserver( br, this );
|
|
}
|
|
}
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::removeObservers(const TNodeVect &nodes)
|
|
{
|
|
for(std::vector<ICDBNode *>::const_iterator it = nodes.begin(); it != nodes.end(); ++it)
|
|
{
|
|
if ((*it)->isLeaf())
|
|
{
|
|
ICDBNode::CTextId textId;
|
|
(*it)->removeObserver(this, textId);
|
|
}
|
|
else
|
|
{
|
|
CCDBNodeBranch *br = static_cast<CCDBNodeBranch *>(*it);
|
|
NLGUI::CDBManager::getInstance()->removeBranchObserver( br, this );
|
|
}
|
|
}
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::updateAllLinks()
|
|
{
|
|
nlassert(!_UpdateAllLinks);
|
|
_UpdateAllLinks = true;
|
|
for(TLinkList::iterator it = _LinkList.begin(); it != _LinkList.end(); ++it)
|
|
{
|
|
CInterfaceLink *pLink = *it;
|
|
pLink->update();
|
|
}
|
|
_UpdateAllLinks = false;
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::update()
|
|
{
|
|
//_On = false; // prvent recursive calls
|
|
if (!_ParseTree) return;
|
|
static TNodeVect observedNodes; // should not be too big, so ok to keep it static.
|
|
static TNodeVect tmpNodes;
|
|
observedNodes.clear();
|
|
CInterfaceExprValue result;
|
|
_ParseTree->evalWithDepends(result, observedNodes);
|
|
// std::set_xxx require ordered container
|
|
std::sort(observedNodes.begin(), observedNodes.end());
|
|
// we assume that _ObservedNode are also sorted
|
|
// compute new observers
|
|
tmpNodes.clear();
|
|
std::set_difference(observedNodes.begin(), observedNodes.end(), _ObservedNodes.begin(), _ObservedNodes.end(), std::back_inserter(tmpNodes));
|
|
// add these observers
|
|
createObservers(tmpNodes);
|
|
// compute lost observers
|
|
tmpNodes.clear();
|
|
std::set_difference(_ObservedNodes.begin(), _ObservedNodes.end(), observedNodes.begin(), observedNodes.end(), std::back_inserter(tmpNodes));
|
|
// remove these observers
|
|
removeObservers(tmpNodes);
|
|
// subsitute new (sorted) list to current
|
|
_ObservedNodes.swap(observedNodes);
|
|
//
|
|
for (uint k = 0; k < _Targets.size(); ++k)
|
|
{
|
|
CInterfaceElement *elem = _Targets[k]._InterfaceElement;
|
|
const CReflectedProperty *prop = _Targets[k]._Property;
|
|
if (elem && prop)
|
|
{
|
|
if (!affect(result, *elem, *prop))
|
|
{
|
|
nlwarning("CInterfaceLink::update: Result conversion failed");
|
|
}
|
|
}
|
|
}
|
|
if (_CDBTargets.size())
|
|
{
|
|
CInterfaceExprValue resultCopy = result;
|
|
if (resultCopy.toInteger())
|
|
{
|
|
sint64 resultValue = resultCopy.getInteger();
|
|
for (uint k = 0; k < _CDBTargets.size(); ++k)
|
|
{
|
|
NLMISC::CCDBNodeLeaf *node = _CDBTargets[k].Leaf;
|
|
if (!node)
|
|
{
|
|
node = _CDBTargets[k].Leaf = NLGUI::CDBManager::getInstance()->getDbProp(_CDBTargets[k].LeafName, false);
|
|
}
|
|
if (node)
|
|
{
|
|
// assuming setvalue64 always works
|
|
node->setValue64(resultValue);
|
|
}
|
|
else
|
|
{
|
|
nlwarning("CInterfaceLink::update: Node does not exist: '%s'", _CDBTargets[k].LeafName.c_str());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("CInterfaceLink::update: Result conversion to db target failed");
|
|
}
|
|
}
|
|
// if there's an action handler, execute it
|
|
if (!_ActionHandler.empty())
|
|
{
|
|
// If there is a condition, test it.
|
|
bool launch = _AHCond.empty();
|
|
if (_AHCondParsed) // todo: maybe makes more sense to make condition also cover target
|
|
{
|
|
CInterfaceExprValue result;
|
|
_AHCondParsed->eval(result);
|
|
launch = result.getBool();
|
|
}
|
|
if (launch)
|
|
{
|
|
CAHManager::getInstance()->runActionHandler(_ActionHandler, _AHParent, _AHParams);
|
|
// do not add any code after this line because this can be deleted !!!!
|
|
}
|
|
}
|
|
|
|
//_On = true; // prevent recursive calls
|
|
}
|
|
|
|
// predicate to remove an element from a list
|
|
struct CRemoveTargetPred
|
|
{
|
|
CInterfaceElement *Target;
|
|
bool operator()(const CInterfaceLink::CTarget &target) const { return target._InterfaceElement == Target; }
|
|
};
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::removeTarget(CInterfaceElement *elem)
|
|
{
|
|
CRemoveTargetPred pred;
|
|
pred.Target = elem;
|
|
_Targets.erase(std::remove_if(_Targets.begin(), _Targets.end(), pred), _Targets.end());
|
|
}
|
|
|
|
//===========================================================
|
|
bool CInterfaceLink::CTargetInfo::affect(const CInterfaceExprValue &value)
|
|
{
|
|
|
|
if (!Elem)
|
|
{
|
|
nlwarning("<CInterfaceLink::CTargetInfo::affect> : Target element is NULL");
|
|
|
|
return false;
|
|
}
|
|
const CReflectedProperty *property = Elem->getReflectedProperty(PropertyName);
|
|
if (!property)
|
|
{
|
|
nlwarning("<CInterfaceLink::CTargetInfo::affect> : Can't retrieve property %s for element %s.", PropertyName.c_str(), Elem->getId().c_str());
|
|
|
|
return false;
|
|
}
|
|
// try to affect the property
|
|
if (!NLGUI::affect(value, *Elem, *property))
|
|
{
|
|
nlwarning("<CInterfaceLink::CTargetInfo::affect> Couldn't convert the value to affect to %s", Elem->getId().c_str());
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::removeAllLinks()
|
|
{
|
|
_LinksWithNoTarget.clear();
|
|
TLinkList::iterator curr = _LinkList.begin();
|
|
TLinkList::iterator nextIt;
|
|
uint k;
|
|
while(curr != _LinkList.end())
|
|
{
|
|
nextIt = curr;
|
|
++ nextIt;
|
|
CInterfaceLink &link = **curr;
|
|
link.checkNbRefs();
|
|
NLMISC::CSmartPtr<CInterfaceLink> linkPtr = *curr; // must keep a smart ptr because of the test in the loop
|
|
for (k = 0; k < link._Targets.size(); ++k)
|
|
{
|
|
if (link._Targets[k]._InterfaceElement)
|
|
{
|
|
nlinfo("InterfaceElement %s was not remove.", link._Targets[k]._InterfaceElement->getId().c_str());
|
|
link._Targets[k]._InterfaceElement->removeLink(&link);
|
|
}
|
|
}
|
|
linkPtr = NULL; // effectively destroy link
|
|
curr = nextIt;
|
|
}
|
|
nlassert(_LinkList.empty());
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CInterfaceLink::splitLinkTarget(const std::string &target, CInterfaceGroup *parentGroup, std::string &propertyName, CInterfaceElement *&targetElm)
|
|
{
|
|
// the last token of the target gives the name of the property
|
|
std::string::size_type lastPos = target.find_last_of(':');
|
|
if (lastPos == (target.length() - 1))
|
|
{
|
|
// todo hulud interface syntax error
|
|
nlwarning("The target should at least contains a path and a property as follow 'path:property'");
|
|
return false;
|
|
}
|
|
std::string elmPath;
|
|
std::string elmProp;
|
|
CInterfaceElement *elm = NULL;
|
|
if (parentGroup)
|
|
{
|
|
if (lastPos == std::string::npos)
|
|
{
|
|
elmProp = target;
|
|
elm = parentGroup;
|
|
elmPath = "current";
|
|
}
|
|
else
|
|
{
|
|
elmProp = target.substr(lastPos + 1);
|
|
elmPath = parentGroup->getId() + ":" + target.substr(0, lastPos);
|
|
elm = parentGroup->getElement(elmPath);
|
|
}
|
|
}
|
|
if (!elm)
|
|
{
|
|
// try the absolute adress of the element
|
|
elmPath = target.substr(0, lastPos);
|
|
elm = CWidgetManager::getInstance()->getElementFromId(elmPath);
|
|
elmProp = target.substr(lastPos + 1);
|
|
}
|
|
|
|
if (!elm)
|
|
{
|
|
// todo hulud interface syntax error
|
|
nlwarning("<splitLinkTarget> can't find target link %s", elmPath.c_str());
|
|
return false;
|
|
}
|
|
targetElm = elm;
|
|
propertyName = elmProp;
|
|
return true;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CInterfaceLink::splitLinkTargets(const std::string &targets, CInterfaceGroup *parentGroup,std::vector<CInterfaceLink::CTargetInfo> &targetsVect)
|
|
{
|
|
std::vector<std::string> targetNames;
|
|
NLMISC::splitString(targets, ",", targetNames);
|
|
targetsVect.clear();
|
|
targetsVect.reserve(targetNames.size());
|
|
bool everythingOk = true;
|
|
for (uint k = 0; k < targetNames.size(); ++k)
|
|
{
|
|
CInterfaceLink::CTargetInfo ti;
|
|
std::string::size_type startPos = targetNames[k].find_first_not_of(" ");
|
|
if(startPos == std::string::npos)
|
|
{
|
|
// todo hulud interface syntax error
|
|
nlwarning("<splitLinkTargets> empty target encountered");
|
|
continue;
|
|
}
|
|
std::string::size_type lastPos = targetNames[k].find_last_not_of(" ");
|
|
if (startPos >= lastPos)
|
|
{
|
|
nlwarning("<splitLinkTargets> empty target encountered");
|
|
continue;
|
|
}
|
|
|
|
if (!splitLinkTarget(targetNames[k].substr(startPos, lastPos - startPos+1), parentGroup, ti.PropertyName, ti.Elem))
|
|
{
|
|
// todo hulud interface syntax error
|
|
nlwarning("<splitLinkTargets> Can't get link target");
|
|
everythingOk = false;
|
|
continue;
|
|
}
|
|
targetsVect.push_back(ti);
|
|
}
|
|
return everythingOk;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CInterfaceLink::splitLinkTargetsExt(const std::string &targets, CInterfaceGroup *parentGroup,std::vector<CInterfaceLink::CTargetInfo> &targetsVect, std::vector<CInterfaceLink::CCDBTargetInfo> &cdbTargetsVect)
|
|
{
|
|
std::vector<std::string> targetNames;
|
|
NLMISC::splitString(targets, ",", targetNames);
|
|
targetsVect.clear();
|
|
targetsVect.reserve(targetNames.size());
|
|
cdbTargetsVect.clear(); // no reserve because less used
|
|
bool everythingOk = true;
|
|
for (uint k = 0; k < targetNames.size(); ++k)
|
|
{
|
|
std::string::size_type startPos = targetNames[k].find_first_not_of(" ");
|
|
if(startPos == std::string::npos)
|
|
{
|
|
// todo hulud interface syntax error
|
|
nlwarning("<splitLinkTargets> empty target encountered");
|
|
continue;
|
|
}
|
|
std::string::size_type lastPos = targetNames[k].find_last_not_of(" ");
|
|
if (startPos >= (lastPos+1))
|
|
{
|
|
nlwarning("<splitLinkTargets> empty target encountered");
|
|
continue;
|
|
}
|
|
|
|
if (targetNames[k][startPos] == '@')
|
|
{
|
|
CInterfaceLink::CCDBTargetInfo ti;
|
|
ti.LeafName = targetNames[k].substr((startPos+1), (lastPos+1) - (startPos+1));
|
|
// Do not allow Write on SERVER: or LOCAL:
|
|
static const std::string dbServer= "SERVER:";
|
|
static const std::string dbLocal= "LOCAL:";
|
|
static const std::string dbLocalR2= "LOCAL:R2";
|
|
if( (0==ti.LeafName.compare(0, dbServer.size(), dbServer)) ||
|
|
(0==ti.LeafName.compare(0, dbLocal.size(), dbLocal))
|
|
)
|
|
{
|
|
if (0!=ti.LeafName.compare(0, dbLocalR2.size(), dbLocalR2))
|
|
{
|
|
//nlwarning("You are not allowed to write on 'SERVER:...' or 'LOCAL:...' database");
|
|
nlstop;
|
|
return false;
|
|
}
|
|
}
|
|
ti.Leaf = NLGUI::CDBManager::getInstance()->getDbProp(ti.LeafName, false);
|
|
cdbTargetsVect.push_back(ti);
|
|
}
|
|
else
|
|
{
|
|
CInterfaceLink::CTargetInfo ti;
|
|
if (!splitLinkTarget(targetNames[k].substr(startPos, lastPos - startPos+1), parentGroup, ti.PropertyName, ti.Elem))
|
|
{
|
|
// todo hulud interface syntax error
|
|
nlwarning("<splitLinkTargets> Can't get link target");
|
|
everythingOk = false;
|
|
continue;
|
|
}
|
|
targetsVect.push_back(ti);
|
|
}
|
|
}
|
|
return everythingOk;
|
|
}
|
|
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::checkNbRefs()
|
|
{
|
|
uint numValidPtr = 0;
|
|
for(uint k = 0; k < _Targets.size(); ++k)
|
|
{
|
|
if (_Targets[k]._InterfaceElement != NULL) ++numValidPtr;
|
|
}
|
|
nlassert(numValidPtr == (uint) crefs);
|
|
}
|
|
|
|
|
|
//===========================================================
|
|
void CInterfaceLink::setTargetProperty (const std::string &Target, const CInterfaceExprValue &val)
|
|
{
|
|
// Eval target !
|
|
string elt = Target.substr(0,Target.rfind(':'));
|
|
CInterfaceElement *pIE = CWidgetManager::getInstance()->getElementFromId(elt);
|
|
CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pIE);
|
|
if (pIG == NULL)
|
|
pIG = pIE->getParent();
|
|
|
|
if (pIG != NULL)
|
|
{
|
|
std::vector<CTargetInfo> vTargets;
|
|
splitLinkTargets(Target, pIG, vTargets);
|
|
if ((vTargets.size() > 0) && (vTargets[0].Elem))
|
|
{
|
|
vTargets[0].affect(val);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CInterfaceLink::linkInTriggerList(uint list)
|
|
{
|
|
nlassert(list < 2);
|
|
if (_Triggered[list]) return; // already inserted in list
|
|
_Triggered[list] = true;
|
|
nlassert(!_PrevTriggeredLink[list]);
|
|
nlassert(!_NextTriggeredLink[list]);
|
|
if (!_FirstTriggeredLink[list])
|
|
{
|
|
_FirstTriggeredLink[list] = _LastTriggeredLink[list] = this;
|
|
}
|
|
else
|
|
{
|
|
nlassert(!_LastTriggeredLink[list]->_NextTriggeredLink[list]);
|
|
_LastTriggeredLink[list]->_NextTriggeredLink[list] = this;
|
|
_PrevTriggeredLink[list] = _LastTriggeredLink[list];
|
|
_LastTriggeredLink[list] = this;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CInterfaceLink::unlinkFromTriggerList(uint list)
|
|
{
|
|
nlassert(list < 2);
|
|
if (!_Triggered[list])
|
|
{
|
|
// not linked in this list
|
|
nlassert(_PrevTriggeredLink[list] == NULL);
|
|
nlassert(_NextTriggeredLink[list] == NULL);
|
|
return;
|
|
}
|
|
if (_PrevTriggeredLink[list])
|
|
{
|
|
_PrevTriggeredLink[list]->_NextTriggeredLink[list] = _NextTriggeredLink[list];
|
|
}
|
|
else
|
|
{
|
|
// this was the first node
|
|
_FirstTriggeredLink[list] = _NextTriggeredLink[list];
|
|
}
|
|
if (_NextTriggeredLink[list])
|
|
{
|
|
_NextTriggeredLink[list]->_PrevTriggeredLink[list] = _PrevTriggeredLink[list];
|
|
}
|
|
else
|
|
{
|
|
// this was the last node
|
|
_LastTriggeredLink[list] = _PrevTriggeredLink[list];
|
|
}
|
|
_PrevTriggeredLink[list] = NULL;
|
|
_NextTriggeredLink[list] = NULL;
|
|
_Triggered[list] = false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------
|
|
void CInterfaceLink::updateTrigeredLinks()
|
|
{
|
|
static bool called = false;
|
|
nlassert(!called);
|
|
called = true;
|
|
_CurrUpdatedLink = _FirstTriggeredLink[_CurrentTriggeredLinkList];
|
|
while (_CurrUpdatedLink)
|
|
{
|
|
// modified node should now store them in other list when they're modified
|
|
_CurrentTriggeredLinkList = 1 - _CurrentTriggeredLinkList;
|
|
// switch list so that modified node are stored in the other list
|
|
while (_CurrUpdatedLink)
|
|
{
|
|
_NextUpdatedLink = _CurrUpdatedLink->_NextTriggeredLink[1 - _CurrentTriggeredLinkList];
|
|
_CurrUpdatedLink->update();
|
|
if (_CurrUpdatedLink) // this may be modified by the call (if current observer is removed)
|
|
{
|
|
_CurrUpdatedLink->unlinkFromTriggerList(1 - _CurrentTriggeredLinkList);
|
|
}
|
|
_CurrUpdatedLink = _NextUpdatedLink;
|
|
}
|
|
nlassert(_FirstTriggeredLink[1 - _CurrentTriggeredLinkList] == NULL);
|
|
nlassert(_LastTriggeredLink[1 - _CurrentTriggeredLinkList] == NULL);
|
|
// examine other list to see if nodes have been registered
|
|
_CurrUpdatedLink = _FirstTriggeredLink[_CurrentTriggeredLinkList];
|
|
}
|
|
called = false;
|
|
}
|
|
|
|
|
|
}
|
|
|