Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/src/gui/interface_expr_user_fct.cpp

1182 lines
27 KiB
C++
Raw Normal View History

merging gui editor repo.
2013-02-14 15:53:06 +00:00
// 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 "nel/gui/interface_expr.h"
#include "nel/gui/interface_link.h"
#include "nel/gui/interface_element.h"
#include "nel/gui/db_manager.h"
#include "nel/misc/i18n.h"
using namespace std;
using namespace NLMISC;
namespace NLGUI
{
void ifexprufct_forcelink()
{
}
// alias to CInterfaceExprValue
typedef CInterfaceExprValue CIEV;
/** takes arguments of a binary operator, and promote them to the best type.
* string are not supported
* \return true
*/
bool promoteToNumericalBestType(CInterfaceExpr::TArgList &_list)
{
uint i;
bool bIsNumerical = true;
for (i = 0 ; i < _list.size(); ++i)
if (!_list[i].isNumerical())
bIsNumerical = false;
if (bIsNumerical)
{
bool bDouble = false;
for (i = 0 ; i < _list.size(); ++i)
if (_list[i].getType() == CIEV::Double)
bDouble = true;
if (bDouble)
{
for (i = 0 ; i < _list.size(); ++i)
_list[i].toDouble();
}
else
{
for (i = 0 ; i < _list.size(); ++i)
_list[i].toInteger();
}
return true;
}
return false;
}
/////////////////////
// ADD 2 numbers //
/////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctAdd)
{
if (!promoteToNumericalBestType(args))
{
nlwarning("add : invalid entry");
return false;
}
switch(args[0].getType())
{
case CIEV::Integer: result.setInteger(args[0].getInteger() + args[1].getInteger()); return true;
case CIEV::Double: result.setDouble(args[0].getDouble() + args[1].getDouble()); return true;
default: break;
}
return false;
}
REGISTER_INTERFACE_USER_FCT("add", userFctAdd)
/////////////////////
// SUB 2 numbers //
/////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctSub)
{
if (!promoteToNumericalBestType(args))
{
nlwarning("sub : invalid entry");
return false;
}
switch(args[0].getType())
{
case CIEV::Integer: result.setInteger(args[0].getInteger() - args[1].getInteger()); return true;
case CIEV::Double: result.setDouble(args[0].getDouble() - args[1].getDouble()); return true;
default: break;
}
return false;
}
REGISTER_INTERFACE_USER_FCT("sub", userFctSub)
///////////////////
// MUL 2 numbers //
///////////////////
static DECLARE_INTERFACE_USER_FCT(userFctMul)
{
if (!promoteToNumericalBestType(args))
{
nlwarning("mul : invalid entry");
return false;
}
switch(args[0].getType())
{
case CIEV::Integer: result.setInteger(args[0].getInteger() * args[1].getInteger()); return true;
case CIEV::Double: result.setDouble(args[0].getDouble() * args[1].getDouble()); return true;
default: break;
}
return false;
}
REGISTER_INTERFACE_USER_FCT("mul", userFctMul)
///////////////////
// DIV 2 numbers //
///////////////////
static DECLARE_INTERFACE_USER_FCT(userFctDiv)
{
if (args.size() != 2 || !args[0].isNumerical() || !args[1].isNumerical())
{
nlwarning("div: bad arguments");
return false;
}
args[0].toDouble();
args[1].toDouble();
if (args[1].getDouble() == 0)
{
nlwarning("div: zero divide");
return false;
}
result.setDouble(args[0].getDouble() / args[1].getDouble());
return true;
}
REGISTER_INTERFACE_USER_FCT("div", userFctDiv)
///////////////////
// MOD 2 numbers //
///////////////////
static DECLARE_INTERFACE_USER_FCT(userFctMod)
{
if (args.size() != 2 || !args[0].isNumerical() || !args[1].isNumerical())
{
nlwarning("mod: bad arguments");
return false;
}
args[0].toDouble();
args[1].toDouble();
if (args[1].getDouble() == 0)
{
nlwarning("mod: zero divide");
return false;
}
result.setDouble(fmod(args[0].getDouble(), args[1].getDouble()));
return true;
}
REGISTER_INTERFACE_USER_FCT("mod", userFctMod)
///////////////////
// abs 1 number //
///////////////////
static DECLARE_INTERFACE_USER_FCT(userFctAbs)
{
if (args.size() != 1 || !args[0].isNumerical())
{
nlwarning("abs: bad arguments");
return false;
}
args[0].toDouble();
result.setDouble(fabs(args[0].getDouble()));
return true;
}
REGISTER_INTERFACE_USER_FCT("abs", userFctAbs)
////////////////////////////////////
// Identity (copy its first arg) //
////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctIdentity)
{
if (args.size() > 0)
{
result = args[0];
return true;
}
else
{
return false;
}
}
REGISTER_INTERFACE_USER_FCT("identity", userFctIdentity)
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Evaluate all of the args, and return 0, so may be used to create dependances on database entries //
//////////////////////////////////////////////////////////////////////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctDepends)
{
result.setInteger(0);
return true;
}
REGISTER_INTERFACE_USER_FCT("depends", userFctDepends)
//////////////////////////
// comparison operators //
//////////////////////////
/** ugly macro to declare comparison operator in a 'compact' way
* this can compare number vs number & string vs string
*/
#define CREATE_CMP_OPERATOR(op, name) \
static DECLARE_INTERFACE_USER_FCT(userFct##name) \
{ \
\
if (args.size() != 2) \
{ \
nlwarning("comparison : bad number of arguments"); \
return false; \
} \
if (args[0].getType() == CIEV::String && args[1].getType() == CIEV::String) \
{ \
result.setBool(strcmp(args[0].getString().c_str(), \
args[1].getString().c_str()) op 0); \
return true; \
} \
if (args.size() != 2 || !args[0].isNumerical() || !args[1].isNumerical()) \
{ \
nlwarning("comparison : arguments are not numerical"); \
return false; \
} \
args[0].toDouble(); \
args[1].toDouble(); \
result.setBool(args[0].getDouble() op args[1].getDouble()); \
return true; \
} \
REGISTER_INTERFACE_USER_FCT(#name, userFct##name)
// declare all comparison operators
//CREATE_CMP_OPERATOR(==, eq)
CREATE_CMP_OPERATOR(!=, ne)
CREATE_CMP_OPERATOR(==, eq)
CREATE_CMP_OPERATOR(< , lt)
CREATE_CMP_OPERATOR(<=, le)
CREATE_CMP_OPERATOR(> , gt)
CREATE_CMP_OPERATOR(>=, ge)
//////////////////
// Logical OR //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctOr)
{
for(uint k = 0; k < args.size(); ++k)
{
if (!args[k].toBool())
{
nlwarning("Argument is not boolean");
return false;
}
if (args[k].getBool())
{
result.setBool(true);
return true;
}
}
result.setBool(false);
return true;
}
REGISTER_INTERFACE_USER_FCT("or", userFctOr)
//////////////////
// Logical AND //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctAnd)
{
for(uint k = 0; k < args.size(); ++k)
{
if (!args[k].toBool())
{
nlwarning("Argument is not boolean");
return false;
}
if (!args[k].getBool())
{
result.setBool(false);
return true;
}
}
result.setBool(true);
return true;
}
REGISTER_INTERFACE_USER_FCT("and", userFctAnd)
//////////////////
// Logical NOT //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctNot)
{
if (args.size() != 1)
{
nlwarning("not : bad number of arguments");
return false;
}
if (!args[0].toBool())
{
nlwarning("Argument is not boolean");
return false;
}
result.setBool(!args[0].getBool());
return true;
}
REGISTER_INTERFACE_USER_FCT("not", userFctNot)
////////////////////////////////////
// String Add Operation //
////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctStr)
{
if (args.size() > 0)
{
ucstring res("");
for (uint32 i = 0; i < args.size(); ++i)
{
args[i].toString();
res += args[i].getUCString();
}
result.setUCString (res);
return true;
}
else
{
return false;
}
}
REGISTER_INTERFACE_USER_FCT("str", userFctStr)
////////////////////////////////////
// Integer Operation //
////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctInt)
{
if (args.size() != 1)
{
return false;
}
args[0].toInteger();
result.setInteger(args[0].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("int", userFctInt)
////////////////////////////////////
// Branching Operation ifthenelse //
////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctIfThenElse)
{
if ((args.size() < 1) || (args.size() > 3))
return false;
if (!args[0].toBool())
return false;
if (args[0].getBool())
{
result = args[1];
}
else
{
if (args.size() == 3)
result = args[2];
else
result.setBool (false);
}
return true;
}
REGISTER_INTERFACE_USER_FCT("ifthenelse", userFctIfThenElse)
////////////////////////////////
// Branching Operation switch //
////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctSwitch)
{
if (args.size() < 2)
return false;
if (!args[0].toInteger())
return false;
sint64 n = args[0].getInteger();
if ((n > ((sint64)args.size()-2)) || (n < 0))
return false;
result = args[(uint)n+1];
return true;
}
REGISTER_INTERFACE_USER_FCT("switch", userFctSwitch)
/////////////////////////////////
// Takes maximum of any numbers //
/////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctMax)
{
// compute type of output
if (!promoteToNumericalBestType(args))
{
nlwarning("max : invalid entry");
return false;
}
uint i;
if (args[0].getType() == CIEV::Integer)
{
sint64 m;
m = args[0].getInteger();
for (i = 1; i < args.size(); ++i)
m = std::max(m,args[i].getInteger());
result.setInteger(m);
}
else
{
double m;
m = args[0].getDouble();
for (i = 1; i < args.size(); ++i)
m = std::max(m,args[i].getDouble());
result.setDouble(m);
}
return true;
}
REGISTER_INTERFACE_USER_FCT("max", userFctMax)
/////////////////////////////////
// Takes minimum of 2 numbers //
/////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctMin)
{
// compute type of output
if (!promoteToNumericalBestType(args))
{
nlwarning("max : invalid entry");
return false;
}
uint i;
if (args[0].getType() == CIEV::Integer)
{
sint64 m;
m = args[0].getInteger();
for (i = 1; i < args.size(); ++i)
m = std::min(m,args[i].getInteger());
result.setInteger(m);
}
else
{
double m;
m = args[0].getDouble();
for (i = 1; i < args.size(); ++i)
m = std::min(m,args[i].getDouble());
result.setDouble(m);
}
return true;
}
REGISTER_INTERFACE_USER_FCT("min", userFctMin)
//////////////////////////////
// Get Reflected Property //
//////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctGetProp)
{
if (args.size() != 1)
return false;
if (args[0].getType() != CIEV::String)
return false;
string sTmp = args[0].getString();
std::vector<CInterfaceLink::CTargetInfo> targetsVector;
CInterfaceLink::splitLinkTargets(sTmp, NULL, targetsVector);
if (targetsVector.empty())
{
nlwarning("no target found");
return false;
}
CInterfaceLink::CTargetInfo &rTI = targetsVector[0];
CInterfaceElement *elem = rTI.Elem;
if (!elem)
{
nlwarning("<CInterfaceExpr::getprop> : Element is NULL");
return false;
}
const CReflectedProperty *pRP = elem->getReflectedProperty(rTI.PropertyName);
if (!pRP) return false;
switch(pRP->Type)
{
case CReflectedProperty::Boolean:
result.setBool ((elem->*(pRP->GetMethod.GetBool))());
break;
case CReflectedProperty::SInt32:
result.setInteger ((elem->*(pRP->GetMethod.GetSInt32))());
break;
case CReflectedProperty::Float:
result.setDouble ((elem->*(pRP->GetMethod.GetFloat))());
break;
case CReflectedProperty::String:
result.setString ((elem->*(pRP->GetMethod.GetString))());
break;
case CReflectedProperty::UCString:
result.setUCString ((elem->*(pRP->GetMethod.GetUCString))());
break;
case CReflectedProperty::RGBA:
result.setRGBA ((elem->*(pRP->GetMethod.GetRGBA))());
break;
default:
nlstop;
return false;
}
return true;
}
REGISTER_INTERFACE_USER_FCT("getprop", userFctGetProp)
///////////////////////////////
// Convert an int to a color //
///////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userIntToColor)
{
if (args.size() != 1)
{
nlwarning("Bad number of args");
return false;
}
if (!args[0].toInteger())
{
nlwarning("Bad type for arg 0 : should be an integer");
return false;
}
CRGBA col;
uint32 intCol = (uint32) args[0].getInteger();
col.R = uint8(intCol & 0xff);
col.G = uint8((intCol >> 8) & 0xff);
col.B = uint8((intCol >> 16) & 0xff);
col.A = uint8((intCol >> 24) & 0xff);
result.setRGBA(col);
return true;
}
REGISTER_INTERFACE_USER_FCT("intToColor", userIntToColor)
///////////////////////////////
// Get components of a color //
///////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userGetRed)
{
if (args.size() != 1)
{
nlwarning("Bad number of args");
return false;
}
if (!args[0].toRGBA())
{
nlwarning("Bad type for arg 0 : should be a color");
return false;
}
result.setInteger((sint64) args[0].getRGBA().R);
return true;
}
REGISTER_INTERFACE_USER_FCT("getRed", userGetRed)
//
static DECLARE_INTERFACE_USER_FCT(userGetGreen)
{
if (args.size() != 1)
{
nlwarning("Bad number of args");
return false;
}
if (!args[0].toRGBA())
{
nlwarning("Bad type for arg 0 : should be a color");
return false;
}
result.setInteger((sint64) args[0].getRGBA().G);
return true;
}
REGISTER_INTERFACE_USER_FCT("getGreen", userGetGreen)
//
static DECLARE_INTERFACE_USER_FCT(userGetBlue)
{
if (args.size() != 1)
{
nlwarning("Bad number of args");
return false;
}
if (!args[0].toRGBA())
{
nlwarning("Bad type for arg 0 : should be a color");
return false;
}
result.setInteger((sint64) args[0].getRGBA().B);
return true;
}
REGISTER_INTERFACE_USER_FCT("getBlue", userGetBlue)
//
static DECLARE_INTERFACE_USER_FCT(userGetAlpha)
{
if (args.size() != 1)
{
nlwarning("Bad number of args");
return false;
}
if (!args[0].toRGBA())
{
nlwarning("Bad type for arg 0 : should be a color");
return false;
}
result.setInteger((sint64) args[0].getRGBA().A);
return true;
}
REGISTER_INTERFACE_USER_FCT("getAlpha", userGetAlpha)
////////////////////////////////////////////////
// make a rgb color from 3 components R, G, B //
////////////////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userMakeRGB)
{
if ((args.size() != 3) && (args.size() != 4))
{
nlwarning("Bad number of args : 3 or 4 args required : R, G, B, [A]");
return false;
}
if (!args[0].toInteger() || !args[1].toInteger() || !args[2].toInteger())
{
nlwarning("Not all args converting to integer");
return false;
}
uint8 nAlpha = 255;
if (args.size() == 4 )
nAlpha = (uint8)args[3].getInteger();
NLMISC::CRGBA col((uint8) args[0].getInteger(), (uint8) args[1].getInteger(), (uint8) args[2].getInteger(),nAlpha);
result.setRGBA(col);
return true;
}
REGISTER_INTERFACE_USER_FCT("makeRGB", userMakeRGB)
//////////////////////////////
// Get number of DB entries //
//////////////////////////////
static DECLARE_INTERFACE_USER_FCT(userDBCount)
{
if (args.size() != 1)
return false;
if (args[0].getType() != CIEV::String)
return false;
string sTmp = args[0].getString();
if (sTmp.find('$') == string::npos)
return false;
string sFirstPart = sTmp.substr(0,sTmp.find('$'));
string sSecondPart = sTmp.substr(sTmp.find('$')+1,sTmp.size());
sint i = 0;
bool bExit = false;
while (!bExit)
{
sTmp = sFirstPart + NLMISC::toString(i) + sSecondPart;
CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(sTmp,false);
CCDBNodeBranch *pNB = NLGUI::CDBManager::getInstance()->getDbBranch(sTmp);
if (pNL != NULL)
{
if (pNL->getValue64() == 0)
bExit = true;
else
++i;
}
else if (pNB != NULL)
{
++i;
}
else
{
bExit = true;
}
}
result.setInteger(i);
return true;
}
REGISTER_INTERFACE_USER_FCT("dbcount", userDBCount)
////////////////////////
// Get a random value //
////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctRand)
{
if ((args.size() != 2) && (args.size() != 0))
return false;
if (args.size() == 2)
{
if (!args[0].toDouble()) return false;
if (!args[1].toDouble()) return false;
double s = args[0].getDouble();
double e = 0.999+args[1].getDouble();
result.setDouble ( s + (e-s)*NLMISC::frand(1.0));
}
else
{
result.setDouble (NLMISC::frand(1.0));
}
return true;
}
REGISTER_INTERFACE_USER_FCT("rand", userFctRand)
static DECLARE_INTERFACE_USER_FCT(userFctGetBit)
{
if (args.size() != 2)
return false;
if (!args[0].toInteger()) return false;
if (!args[1].toInteger()) return false;
sint64 i = args[0].getInteger();
sint64 s = args[1].getInteger();
result.setInteger (0);
if ((i & (SINT64_CONSTANT(1)<<s)) != 0)
result.setInteger (1);
return true;
}
REGISTER_INTERFACE_USER_FCT("getbit", userFctGetBit)
// ***********************
// INTERPOLATION FUNCTIONS
// ***********************
//////////////
// i_linear //
//////////////
static DECLARE_INTERFACE_USER_FCT(userFctILinear)
{
if (args.size() != 3)
return false;
if (!args[0].toDouble()) return false;
if (!args[1].toDouble()) return false;
if (!args[2].toDouble()) return false;
double i = args[0].getDouble(); // Interpolant
double s = args[1].getDouble(); // Start
double e = args[2].getDouble(); // End
result.setDouble ( s + i * (e - s) );
return true;
}
REGISTER_INTERFACE_USER_FCT("ilinear", userFctILinear)
//////////////////
// Bitwise OR //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctBitOr)
{
uint64 res= 0;
for(uint k = 0; k < args.size(); ++k)
{
if (!args[k].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
res|= args[k].getInteger();
}
result.setInteger(res);
return true;
}
REGISTER_INTERFACE_USER_FCT("bor", userFctBitOr)
//////////////////
// Bitwise AND //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctBitAnd)
{
if(args.empty())
{
result.setInteger(0);
return true;
}
uint64 res= UINT64_CONSTANT(0xFFFFFFFFFFFFFFFF);
for(uint k = 0; k < args.size(); ++k)
{
if (!args[k].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
res&= args[k].getInteger();
}
result.setInteger(res);
return true;
}
REGISTER_INTERFACE_USER_FCT("band", userFctBitAnd)
//////////////////
// Bitwise NOT //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctBitNot)
{
if (args.size() != 1)
{
nlwarning("bnot : bad number of arguments");
return false;
}
if (!args[0].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
result.setInteger(~args[0].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("bnot", userFctBitNot)
//////////////////
// Bitwise XOR //
//////////////////
static DECLARE_INTERFACE_USER_FCT(userFctBitXor)
{
if (args.size() != 2)
{
nlwarning("bxor : bad number of arguments");
return false;
}
if (!args[0].toInteger() || !args[1].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
result.setInteger(args[0].getInteger() ^ args[1].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("bxor", userFctBitXor)
///////////////////////////
// Unsigned right shift //
///////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctSHR)
{
if (args.size() != 2)
{
nlwarning("shr : bad number of arguments");
return false;
}
if (!args[0].toInteger() || !args[1].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
result.setInteger(((uint64)args[0].getInteger()) >> args[1].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("shr", userFctSHR)
//////////////////////////
// Unsigned left shift //
//////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctSHL)
{
if (args.size() != 2)
{
nlwarning("shl : bad number of arguments");
return false;
}
if (!args[0].toInteger() || !args[1].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
result.setInteger(((uint64)args[0].getInteger()) << args[1].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("shl", userFctSHL)
/////////////////////////
// Signed right shift //
/////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctSAR)
{
if (args.size() != 2)
{
nlwarning("sar : bad number of arguments");
return false;
}
if (!args[0].toInteger() || !args[1].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
result.setInteger(args[0].getInteger() >> args[1].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("sar", userFctSAR)
////////////////////////
// Signed left shift //
////////////////////////
static DECLARE_INTERFACE_USER_FCT(userFctSAL)
{
if (args.size() != 2)
{
nlwarning("sal : bad number of arguments");
return false;
}
if (!args[0].toInteger() || !args[1].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
result.setInteger(args[0].getInteger() << args[1].getInteger());
return true;
}
REGISTER_INTERFACE_USER_FCT("sal", userFctSAL)
/////////////////////////////////////////////////////////////////////////////
// Extend the sign of the argument considered over 8 bits to a 64 bits int //
/////////////////////////////////////////////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(extSign8To64)
{
if (args.size() != 1)
{
nlwarning("extSign8To64 : bad number of arguments");
return false;
}
if (!args[0].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
sint8 i = (sint8)args[0].getInteger();
result.setInteger((sint64)i);
return true;
}
REGISTER_INTERFACE_USER_FCT("extSign8To64", extSign8To64)
//////////////////////////////////////////////////////////////////////////////
// Extend the sign of the argument considered over 11 bits to a 64 bits int //
//////////////////////////////////////////////////////////////////////////////
static DECLARE_INTERFACE_USER_FCT(extSign11To64)
{
if (args.size() != 1)
{
nlwarning("extSign12To64 : bad number of arguments");
return false;
}
if (!args[0].toInteger())
{
nlwarning("Argument is not integer");
return false;
}
sint32 i = (sint16)args[0].getInteger() & 0x7ff;
if( i > 1023 )
i |= 0xfffff800;
result.setInteger((sint64)i);
return true;
}
REGISTER_INTERFACE_USER_FCT("extSign11To64", extSign11To64)
////////////////////////
// Ryzom version info //
////////////////////////
static DECLARE_INTERFACE_USER_FCT(isFinalVersion)
{
if (!args.empty())
{
nlwarning("isFinalVersion : no args required");
return false;
}
#if FINAL_VERSION
result.setBool(true);
#else
result.setBool(false);
#endif
return true;
}
REGISTER_INTERFACE_USER_FCT("isFinalVersion", isFinalVersion)
////////////////////////
////////////////////////
static DECLARE_INTERFACE_USER_FCT(secondsToTimeString)
{
if (args.size() != 1)
{
nlwarning("intToTimeString : 1 args required");
return false;
}
if (!args[0].toInteger())
{
nlwarning("intToTimeString : args 0 required to be an int");
return false;
}
sint64 nVal = args[0].getInteger();
ucstring sTmp;
if (nVal < 0) nVal = 0;
sTmp = toString(nVal % 60) + " " + CI18N::get("uiMissionTimerSecond");
nVal = nVal / 60;
if( nVal > 0 )
{
sTmp = toString(nVal % 60) + " " + CI18N::get("uiMissionTimerMinute") + " " + sTmp;
nVal = nVal / 60;
if( nVal > 0 )
{
sTmp = toString(nVal % 24) + " " + CI18N::get("uiMissionTimerHour") + " " + sTmp;
nVal = nVal / 24;
if( nVal > 0 )
{
sTmp = toString(nVal) + " " + CI18N::get("uiMissionTimerDay") + " " + sTmp;
}
}
}
result.setUCString(sTmp);
return true;
}
REGISTER_INTERFACE_USER_FCT("secondsToTimeString", secondsToTimeString)
////////////////////////
////////////////////////
static DECLARE_INTERFACE_USER_FCT(secondsToTimeStringShort)
{
if (args.size() != 1)
{
nlwarning("intToTimeString : 1 args required");
return false;
}
if (!args[0].toInteger())
{
nlwarning("intToTimeString : args 0 required to be an int");
return false;
}
sint64 nVal = args[0].getInteger();
ucstring sTmp;
if (nVal < 0) nVal = 0;
sTmp = toString("%02d", nVal % 60);
nVal = nVal / 60;
if( nVal > 0 )
{
sTmp = toString(nVal % 60) + "'" + sTmp;
nVal = nVal / 60;
// if at least one hour, just display number of hour
if( nVal > 0 )
{
sTmp = toString(nVal % 24) + "h";
nVal = nVal / 24;
// if at least one hour, just display number of days
if( nVal > 0 )
{
sTmp = toString(nVal) + "d";
}
}
}
result.setUCString(sTmp);
return true;
}
REGISTER_INTERFACE_USER_FCT("secondsToTimeStringShort", secondsToTimeStringShort)
////////////////////////
////////////////////////
static DECLARE_INTERFACE_USER_FCT(oldvalue)
{
if (args.size() != 1)
{
nlwarning("oldvalue : 1 arg required");
return false;
}
CCDBNodeLeaf *nl = NLGUI::CDBManager::getInstance()->getDbProp(args[0].getString());
if (!nl)
{
nlwarning("oldvalue : arg 0 required to be an interface leaf");
return false;
}
result.setInteger (nl->getOldValue64());
return true;
}
REGISTER_INTERFACE_USER_FCT("oldvalue", oldvalue)
////////////////////////
////////////////////////
static DECLARE_INTERFACE_USER_FCT(localize)
{
if (args.size() != 1)
{
nlwarning("localize : 1 arg required");
return false;
}
result.setUCString(CI18N::get(args[0].getString()));
return true;
}
REGISTER_INTERFACE_USER_FCT("localize", localize);
}
Reference in a new issue Copy permalink