nel/src/gui/interface_expr_user_fct.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2019-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22 #include "stdpch.h"
  23 #include "nel/gui/interface_expr.h"
  24 #include "nel/gui/interface_link.h"
  25 #include "nel/gui/interface_element.h"
  26 #include "nel/gui/db_manager.h"
  27 #include "nel/misc/i18n.h"
  28
  29 using namespace std;
  30 using namespace NLMISC;
  31
  32 #ifdef DEBUG_NEW
  33 #define new DEBUG_NEW
  34 #endif
  35
  36 namespace NLGUI
  37 {
  38
  39         void ifexprufct_forcelink()
  40         {
  41         }
  42
  43
  44         // alias to CInterfaceExprValue
  45         typedef CInterfaceExprValue CIEV;
  46
  47         /** takes arguments of a binary operator, and promote them to the best type.
  48           * string are not supported
  49           * \return true
  50           */
  51         bool promoteToNumericalBestType(CInterfaceExpr::TArgList &_list)
  52         {
  53                 uint i;
  54                 bool bIsNumerical = true;
  55
  56                 for (i = 0 ; i < _list.size(); ++i)
  57                         if (!_list[i].isNumerical())
  58                                 bIsNumerical = false;
  59
  60                 if (bIsNumerical)
  61                 {
  62                         bool bDouble = false;
  63
  64                         for (i = 0 ; i < _list.size(); ++i)
  65                                 if (_list[i].getType() == CIEV::Double)
  66                                         bDouble = true;
  67
  68                         if (bDouble)
  69                         {
  70                                 for (i = 0 ; i < _list.size(); ++i)
  71                                         _list[i].toDouble();
  72                         }
  73                         else
  74                         {
  75                                 for (i = 0 ; i < _list.size(); ++i)
  76                                         _list[i].toInteger();
  77                         }
  78                         return true;
  79                 }
  80
  81                 return false;
  82         }
  83
  84
  85         /////////////////////
  86         //  ADD 2 numbers  //
  87         /////////////////////
  88
  89         static DECLARE_INTERFACE_USER_FCT(userFctAdd)
  90         {
  91                 if (!promoteToNumericalBestType(args))
  92                 {
  93                         nlwarning("add : invalid entry");
  94                         return false;
  95                 }
  96                 switch(args[0].getType())
  97                 {
  98                         case CIEV::Integer: result.setInteger(args[0].getInteger() + args[1].getInteger()); return true;
  99                         case CIEV::Double: result.setDouble(args[0].getDouble() + args[1].getDouble()); return true;
 100                         default: break;
 101                 }
 102                 return false;
 103         }
 104         REGISTER_INTERFACE_USER_FCT("add", userFctAdd)
 105
 106         /////////////////////
 107         //   SUB 2 numbers //
 108         /////////////////////
 109
 110         static DECLARE_INTERFACE_USER_FCT(userFctSub)
 111         {
 112                 if (!promoteToNumericalBestType(args))
 113                 {
 114                         nlwarning("sub : invalid entry");
 115                         return false;
 116                 }
 117                 switch(args[0].getType())
 118                 {
 119                         case CIEV::Integer: result.setInteger(args[0].getInteger() - args[1].getInteger()); return true;
 120                         case CIEV::Double: result.setDouble(args[0].getDouble() - args[1].getDouble()); return true;
 121                         default: break;
 122                 }
 123                 return false;
 124         }
 125         REGISTER_INTERFACE_USER_FCT("sub", userFctSub)
 126
 127         ///////////////////
 128         // MUL 2 numbers //
 129         ///////////////////
 130
 131         static DECLARE_INTERFACE_USER_FCT(userFctMul)
 132         {
 133                 if (!promoteToNumericalBestType(args))
 134                 {
 135                         nlwarning("mul : invalid entry");
 136                         return false;
 137                 }
 138                 switch(args[0].getType())
 139                 {
 140                         case CIEV::Integer: result.setInteger(args[0].getInteger() * args[1].getInteger()); return true;
 141                         case CIEV::Double: result.setDouble(args[0].getDouble() * args[1].getDouble()); return true;
 142                         default: break;
 143                 }
 144                 return false;
 145         }
 146         REGISTER_INTERFACE_USER_FCT("mul", userFctMul)
 147
 148         ///////////////////
 149         // DIV 2 numbers //
 150         ///////////////////
 151
 152         static DECLARE_INTERFACE_USER_FCT(userFctDiv)
 153         {
 154                 if (args.size() != 2 || !args[0].isNumerical() || !args[1].isNumerical())
 155                 {
 156                         nlwarning("div: bad arguments");
 157                         return false;
 158                 }
 159                 args[0].toDouble();
 160                 args[1].toDouble();
 161                 if (args[1].getDouble() == 0)
 162                 {
 163                         nlwarning("div: zero divide");
 164                         return false;
 165                 }
 166                 result.setDouble(args[0].getDouble() / args[1].getDouble());
 167                 return true;
 168         }
 169         REGISTER_INTERFACE_USER_FCT("div", userFctDiv)
 170
 171         ///////////////////
 172         // MOD 2 numbers //
 173         ///////////////////
 174
 175         static DECLARE_INTERFACE_USER_FCT(userFctMod)
 176         {
 177                 if (args.size() != 2 || !args[0].isNumerical() || !args[1].isNumerical())
 178                 {
 179                         nlwarning("mod: bad arguments");
 180                         return false;
 181                 }
 182                 args[0].toDouble();
 183                 args[1].toDouble();
 184                 if (args[1].getDouble() == 0)
 185                 {
 186                         nlwarning("mod: zero divide");
 187                         return false;
 188                 }
 189                 result.setDouble(fmod(args[0].getDouble(), args[1].getDouble()));
 190                 return true;
 191         }
 192         REGISTER_INTERFACE_USER_FCT("mod", userFctMod)
 193
 194         ///////////////////
 195         // abs 1 number  //
 196         ///////////////////
 197
 198         static DECLARE_INTERFACE_USER_FCT(userFctAbs)
 199         {
 200                 if (args.size() != 1 || !args[0].isNumerical())
 201                 {
 202                         nlwarning("abs: bad arguments");
 203                         return false;
 204                 }
 205                 args[0].toDouble();
 206                 result.setDouble(fabs(args[0].getDouble()));
 207                 return true;
 208         }
 209         REGISTER_INTERFACE_USER_FCT("abs", userFctAbs)
 210
 211         ////////////////////////////////////
 212         // Identity  (copy its first arg) //
 213         ////////////////////////////////////
 214
 215         static DECLARE_INTERFACE_USER_FCT(userFctIdentity)
 216         {
 217                 if (!args.empty())
 218                 {
 219                         result = args[0];
 220                         return true;
 221                 }
 222                 else
 223                 {
 224                         return false;
 225                 }
 226         }
 227         REGISTER_INTERFACE_USER_FCT("identity", userFctIdentity)
 228
 229
 230         //////////////////////////////////////////////////////////////////////////////////////////////////////
 231         // Evaluate all of the args, and return 0, so may be used to create dependances on database entries //
 232         //////////////////////////////////////////////////////////////////////////////////////////////////////
 233         static DECLARE_INTERFACE_USER_FCT(userFctDepends)
 234         {
 235                 result.setInteger(0);
 236                 return true;
 237         }
 238         REGISTER_INTERFACE_USER_FCT("depends", userFctDepends)
 239
 240
 241         //////////////////////////
 242         // comparison operators //
 243         //////////////////////////
 244
 245         /** ugly macro to declare comparison operator in a 'compact' way
 246           * this can compare number vs number & string vs string
 247           */
 248         #define CREATE_CMP_OPERATOR(op, name)                                            \
 249         static DECLARE_INTERFACE_USER_FCT(userFct##name)                                 \
 250         {                                                                                \
 251                                                                                                                                                                          \
 252                 if (args.size() != 2)                                                        \
 253                 {                                                                            \
 254                         nlwarning("comparison : bad number of arguments");                       \
 255                         return false;                                                            \
 256                 }                                                                            \
 257                 if (args[0].getType() == CIEV::String && args[1].getType() == CIEV::String)  \
 258                 {                                                                                                                                                        \
 259                         result.setBool(strcmp(args[0].getString().c_str(),                       \
 260                                                    args[1].getString().c_str()) op 0);                       \
 261                         return true;                                                             \
 262                 }                                                                                                                                                        \
 263                 if (args.size() != 2 || !args[0].isNumerical() || !args[1].isNumerical())    \
 264                 {                                                                            \
 265                         nlwarning("comparison : arguments are not numerical");                   \
 266                         return false;                                                            \
 267                 }                                                                            \
 268                 args[0].toDouble();                                                          \
 269                 args[1].toDouble();                                                              \
 270                 result.setBool(args[0].getDouble() op args[1].getDouble());                  \
 271                 return true;                                                                 \
 272         }                                                                                                                                                                \
 273         REGISTER_INTERFACE_USER_FCT(#name, userFct##name)
 274
 275
 276
 277         // declare all comparison operators
 278         //CREATE_CMP_OPERATOR(==, eq)
 279         CREATE_CMP_OPERATOR(!=, ne)
 280         CREATE_CMP_OPERATOR(==, eq)
 281         CREATE_CMP_OPERATOR(< , lt)
 282         CREATE_CMP_OPERATOR(<=, le)
 283         CREATE_CMP_OPERATOR(> , gt)
 284         CREATE_CMP_OPERATOR(>=, ge)
 285
 286
 287
 288         //////////////////
 289         // Logical OR   //
 290         //////////////////
 291         static DECLARE_INTERFACE_USER_FCT(userFctOr)
 292         {
 293                 for(uint k = 0; k < args.size(); ++k)
 294                 {
 295                         if (!args[k].toBool())
 296                         {
 297                                 nlwarning("Argument is not boolean");
 298                                 return false;
 299                         }
 300                         if (args[k].getBool())
 301                         {
 302                                 result.setBool(true);
 303                                 return true;
 304                         }
 305                 }
 306                 result.setBool(false);
 307                 return true;
 308         }
 309         REGISTER_INTERFACE_USER_FCT("or", userFctOr)
 310
 311         //////////////////
 312         // Logical AND  //
 313         //////////////////
 314         static DECLARE_INTERFACE_USER_FCT(userFctAnd)
 315         {
 316                 for(uint k = 0; k < args.size(); ++k)
 317                 {
 318                         if (!args[k].toBool())
 319                         {
 320                                 nlwarning("Argument is not boolean");
 321                                 return false;
 322                         }
 323                         if (!args[k].getBool())
 324                         {
 325                                 result.setBool(false);
 326                                 return true;
 327                         }
 328                 }
 329                 result.setBool(true);
 330                 return true;
 331         }
 332         REGISTER_INTERFACE_USER_FCT("and", userFctAnd)
 333
 334         //////////////////
 335         // Logical NOT  //
 336         //////////////////
 337         static DECLARE_INTERFACE_USER_FCT(userFctNot)
 338         {
 339                 if (args.size() != 1)
 340                 {
 341                         nlwarning("not : bad number of arguments");
 342                         return false;
 343                 }
 344                 if (!args[0].toBool())
 345                 {
 346                         nlwarning("Argument is not boolean");
 347                         return false;
 348                 }
 349                 result.setBool(!args[0].getBool());
 350                 return true;
 351         }
 352         REGISTER_INTERFACE_USER_FCT("not", userFctNot)
 353
 354
 355         ////////////////////////////////////
 356         // String Add Operation           //
 357         ////////////////////////////////////
 358
 359         static DECLARE_INTERFACE_USER_FCT(userFctStr)
 360         {
 361                 if (!args.empty())
 362                 {
 363                         string res;
 364                         for (uint32 i = 0; i < args.size(); ++i)
 365                         {
 366                                 args[i].toString();
 367                                 res += args[i].getString();
 368                         }
 369                         result.setString (res);
 370
 371                         return true;
 372                 }
 373                 else
 374                 {
 375                         return false;
 376                 }
 377         }
 378         REGISTER_INTERFACE_USER_FCT("str", userFctStr)
 379
 380         ////////////////////////////////////
 381         // Integer Operation           //
 382         ////////////////////////////////////
 383
 384         static DECLARE_INTERFACE_USER_FCT(userFctInt)
 385         {
 386                 if (args.size() != 1)
 387                 {
 388                         return false;
 389                 }
 390
 391                 args[0].toInteger();
 392                 result.setInteger(args[0].getInteger());
 393                 return true;
 394         }
 395         REGISTER_INTERFACE_USER_FCT("int", userFctInt)
 396
 397         ////////////////////////////////////
 398         // Branching Operation ifthenelse //
 399         ////////////////////////////////////
 400
 401         static DECLARE_INTERFACE_USER_FCT(userFctIfThenElse)
 402         {
 403                 if ((args.size() < 1) || (args.size() > 3))
 404                         return false;
 405
 406                 if (!args[0].toBool())
 407                         return false;
 408
 409                 if (args[0].getBool())
 410                 {
 411                         result = args[1];
 412                 }
 413                 else
 414                 {
 415                         if (args.size() == 3)
 416                                 result = args[2];
 417                         else
 418                                 result.setBool (false);
 419                 }
 420
 421                 return true;
 422         }
 423         REGISTER_INTERFACE_USER_FCT("ifthenelse", userFctIfThenElse)
 424
 425         ////////////////////////////////
 426         // Branching Operation switch //
 427         ////////////////////////////////
 428
 429         static DECLARE_INTERFACE_USER_FCT(userFctSwitch)
 430         {
 431                 if (args.size() < 2)
 432                         return false;
 433
 434                 if (!args[0].toInteger())
 435                         return false;
 436
 437                 sint64 n = args[0].getInteger();
 438                 if ((n > ((sint64)args.size()-2)) || (n < 0))
 439                         return false;
 440
 441                 result = args[(uint)n+1];
 442
 443                 return true;
 444         }
 445         REGISTER_INTERFACE_USER_FCT("switch", userFctSwitch)
 446
 447         /////////////////////////////////
 448         // Takes maximum of any numbers //
 449         /////////////////////////////////
 450         static DECLARE_INTERFACE_USER_FCT(userFctMax)
 451         {
 452                 // compute type of output
 453                 if (!promoteToNumericalBestType(args))
 454                 {
 455                         nlwarning("max : invalid entry");
 456                         return false;
 457                 }
 458                 uint i;
 459                 if (args[0].getType() == CIEV::Integer)
 460                 {
 461                         sint64 m;
 462                         m = args[0].getInteger();
 463                         for (i = 1; i < args.size(); ++i)
 464                                 m = std::max(m,args[i].getInteger());
 465                         result.setInteger(m);
 466                 }
 467                 else
 468                 {
 469                         double m;
 470                         m = args[0].getDouble();
 471                         for (i = 1; i < args.size(); ++i)
 472                                 m = std::max(m,args[i].getDouble());
 473                         result.setDouble(m);
 474                 }
 475                 return true;
 476         }
 477         REGISTER_INTERFACE_USER_FCT("max", userFctMax)
 478
 479         /////////////////////////////////
 480         // Takes minimum of 2 numbers  //
 481         /////////////////////////////////
 482         static DECLARE_INTERFACE_USER_FCT(userFctMin)
 483         {
 484                 // compute type of output
 485                 if (!promoteToNumericalBestType(args))
 486                 {
 487                         nlwarning("max : invalid entry");
 488                         return false;
 489                 }
 490                 uint i;
 491                 if (args[0].getType() == CIEV::Integer)
 492                 {
 493                         sint64 m;
 494                         m = args[0].getInteger();
 495                         for (i = 1; i < args.size(); ++i)
 496                                 m = std::min(m,args[i].getInteger());
 497                         result.setInteger(m);
 498                 }
 499                 else
 500                 {
 501                         double m;
 502                         m = args[0].getDouble();
 503                         for (i = 1; i < args.size(); ++i)
 504                                 m = std::min(m,args[i].getDouble());
 505                         result.setDouble(m);
 506                 }
 507                 return true;
 508         }
 509         REGISTER_INTERFACE_USER_FCT("min", userFctMin)
 510
 511         //////////////////////////////
 512         // Get Reflected Property   //
 513         //////////////////////////////
 514         static DECLARE_INTERFACE_USER_FCT(userFctGetProp)
 515         {
 516                 if (args.size() != 1)
 517                         return false;
 518
 519                 if (args[0].getType() != CIEV::String)
 520                         return false;
 521
 522                 string sTmp = args[0].getString();
 523                 std::vector<CInterfaceLink::CTargetInfo> targetsVector;
 524                 CInterfaceLink::splitLinkTargets(sTmp, NULL, targetsVector);
 525
 526                 if (targetsVector.empty())
 527                 {
 528                         nlwarning("no target found");
 529                         return false;
 530                 }
 531                 CInterfaceLink::CTargetInfo &rTI = targetsVector[0];
 532
 533                 CInterfaceElement *elem = rTI.Elem;
 534                 if (!elem)
 535                 {
 536                         nlwarning("<CInterfaceExpr::getprop> : Element is NULL");
 537                         return false;
 538                 }
 539                 const CReflectedProperty *pRP = elem->getReflectedProperty(rTI.PropertyName);
 540
 541                 if (!pRP) return false;
 542                 switch(pRP->Type)
 543                 {
 544                         case CReflectedProperty::Boolean:
 545                                 result.setBool ((elem->*(pRP->GetMethod.GetBool))());
 546                         break;
 547                         case CReflectedProperty::SInt32:
 548                                 result.setInteger ((elem->*(pRP->GetMethod.GetSInt32))());
 549                         break;
 550                         case CReflectedProperty::Float:
 551                                 result.setDouble ((elem->*(pRP->GetMethod.GetFloat))());
 552                         break;
 553                         case CReflectedProperty::String:
 554                                 result.setString ((elem->*(pRP->GetMethod.GetString))());
 555                         break;
 556 #ifdef RYZOM_LUA_UCSTRING
 557                         case CReflectedProperty::UCString:
 558                                 result.setString ((elem->*(pRP->GetMethod.GetUCString))().toUtf8());
 559                         break;
 560 #endif
 561                         case CReflectedProperty::StringRef:
 562                                 result.setString ((elem->*(pRP->GetMethod.GetStringRef))());
 563                         break;
 564 #ifdef RYZOM_LUA_UCSTRING
 565                         case CReflectedProperty::UCStringRef:
 566                                 result.setString ((elem->*(pRP->GetMethod.GetUCStringRef))().toUtf8());
 567                         break;
 568 #endif
 569                         case CReflectedProperty::RGBA:
 570                                 result.setRGBA ((elem->*(pRP->GetMethod.GetRGBA))());
 571                         break;
 572                         default:
 573                                 nlstop;
 574                                 return false;
 575                 }
 576                 return true;
 577         }
 578         REGISTER_INTERFACE_USER_FCT("getprop", userFctGetProp)
 579
 580
 581         ///////////////////////////////
 582         // Convert an int to a color //
 583         ///////////////////////////////
 584         static DECLARE_INTERFACE_USER_FCT(userIntToColor)
 585         {
 586                 if (args.size() != 1)
 587                 {
 588                         nlwarning("Bad number of args");
 589                         return false;
 590                 }
 591                 if (!args[0].toInteger())
 592                 {
 593                         nlwarning("Bad type for arg 0 : should be an integer");
 594                         return false;
 595                 }
 596                 CRGBA col;
 597                 uint32 intCol = (uint32) args[0].getInteger();
 598                 col.R = uint8(intCol & 0xff);
 599                 col.G = uint8((intCol >> 8) & 0xff);
 600                 col.B = uint8((intCol >> 16) & 0xff);
 601                 col.A = uint8((intCol >> 24) & 0xff);
 602                 result.setRGBA(col);
 603                 return true;
 604         }
 605         REGISTER_INTERFACE_USER_FCT("intToColor", userIntToColor)
 606
 607         ///////////////////////////////
 608         // Get components of a color //
 609         ///////////////////////////////
 610         static DECLARE_INTERFACE_USER_FCT(userGetRed)
 611         {
 612                 if (args.size() != 1)
 613                 {
 614                         nlwarning("Bad number of args");
 615                         return false;
 616                 }
 617                 if (!args[0].toRGBA())
 618                 {
 619                         nlwarning("Bad type for arg 0 : should be a color");
 620                         return false;
 621                 }
 622                 result.setInteger((sint64) args[0].getRGBA().R);
 623                 return true;
 624         }
 625         REGISTER_INTERFACE_USER_FCT("getRed", userGetRed)
 626         //
 627         static DECLARE_INTERFACE_USER_FCT(userGetGreen)
 628         {
 629                 if (args.size() != 1)
 630                 {
 631                         nlwarning("Bad number of args");
 632                         return false;
 633                 }
 634                 if (!args[0].toRGBA())
 635                 {
 636                         nlwarning("Bad type for arg 0 : should be a color");
 637                         return false;
 638                 }
 639                 result.setInteger((sint64) args[0].getRGBA().G);
 640                 return true;
 641         }
 642         REGISTER_INTERFACE_USER_FCT("getGreen", userGetGreen)
 643         //
 644         static DECLARE_INTERFACE_USER_FCT(userGetBlue)
 645         {
 646                 if (args.size() != 1)
 647                 {
 648                         nlwarning("Bad number of args");
 649                         return false;
 650                 }
 651                 if (!args[0].toRGBA())
 652                 {
 653                         nlwarning("Bad type for arg 0 : should be a color");
 654                         return false;
 655                 }
 656                 result.setInteger((sint64) args[0].getRGBA().B);
 657                 return true;
 658         }
 659         REGISTER_INTERFACE_USER_FCT("getBlue", userGetBlue)
 660         //
 661         static DECLARE_INTERFACE_USER_FCT(userGetAlpha)
 662         {
 663                 if (args.size() != 1)
 664                 {
 665                         nlwarning("Bad number of args");
 666                         return false;
 667                 }
 668                 if (!args[0].toRGBA())
 669                 {
 670                         nlwarning("Bad type for arg 0 : should be a color");
 671                         return false;
 672                 }
 673                 result.setInteger((sint64) args[0].getRGBA().A);
 674                 return true;
 675         }
 676         REGISTER_INTERFACE_USER_FCT("getAlpha", userGetAlpha)
 677
 678         ////////////////////////////////////////////////
 679         // make a rgb color from 3 components R, G, B //
 680         ////////////////////////////////////////////////
 681         static DECLARE_INTERFACE_USER_FCT(userMakeRGB)
 682         {
 683                 if ((args.size() != 3) && (args.size() != 4))
 684                 {
 685                         nlwarning("Bad number of args : 3 or 4 args required : R, G, B, [A]");
 686                         return false;
 687                 }
 688                 if (!args[0].toInteger() || !args[1].toInteger() || !args[2].toInteger())
 689                 {
 690                         nlwarning("Not all args converting to integer");
 691                         return false;
 692                 }
 693                 uint8 nAlpha = 255;
 694                 if (args.size() == 4 )
 695                         nAlpha = (uint8)args[3].getInteger();
 696
 697                 NLMISC::CRGBA col((uint8) args[0].getInteger(), (uint8) args[1].getInteger(), (uint8) args[2].getInteger(),nAlpha);
 698                 result.setRGBA(col);
 699
 700                 return true;
 701         }
 702         REGISTER_INTERFACE_USER_FCT("makeRGB", userMakeRGB)
 703
 704
 705         //////////////////////////////
 706         // Get number of DB entries //
 707         //////////////////////////////
 708         static DECLARE_INTERFACE_USER_FCT(userDBCount)
 709         {
 710                 if (args.size() != 1)
 711                         return false;
 712
 713                 if (args[0].getType() != CIEV::String)
 714                         return false;
 715
 716                 string sTmp = args[0].getString();
 717
 718                 if (sTmp.find('$') == string::npos)
 719                         return false;
 720
 721                 string sFirstPart = sTmp.substr(0,sTmp.find('$'));
 722                 string sSecondPart = sTmp.substr(sTmp.find('$')+1,sTmp.size());
 723
 724                 sint i = 0;
 725                 bool bExit = false;
 726
 727                 while (!bExit)
 728                 {
 729                         sTmp = sFirstPart + NLMISC::toString(i) + sSecondPart;
 730                         CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(sTmp,false);
 731                         CCDBNodeBranch *pNB = NLGUI::CDBManager::getInstance()->getDbBranch(sTmp);
 732                         if (pNL != NULL)
 733                         {
 734                                 if (pNL->getValue64() == 0)
 735                                         bExit = true;
 736                                 else
 737                                         ++i;
 738                         }
 739                         else if (pNB != NULL)
 740                         {
 741                                 ++i;
 742                         }
 743                         else
 744                         {
 745                                 bExit = true;
 746                         }
 747                 }
 748
 749                 result.setInteger(i);
 750
 751                 return true;
 752         }
 753         REGISTER_INTERFACE_USER_FCT("dbcount", userDBCount)
 754
 755         ////////////////////////
 756         // Get a random value //
 757         ////////////////////////
 758         static DECLARE_INTERFACE_USER_FCT(userFctRand)
 759         {
 760                 if ((args.size() != 2) && (args.size() != 0))
 761                         return false;
 762
 763                 if (args.size() == 2)
 764                 {
 765                         if (!args[0].toDouble()) return false;
 766                         if (!args[1].toDouble()) return false;
 767
 768                         double s = args[0].getDouble();
 769                         double e = 0.999+args[1].getDouble();
 770
 771                         result.setDouble ( s + (e-s)*NLMISC::frand(1.0));
 772                 }
 773                 else
 774                 {
 775                         result.setDouble (NLMISC::frand(1.0));
 776                 }
 777
 778                 return true;
 779         }
 780         REGISTER_INTERFACE_USER_FCT("rand", userFctRand)
 781
 782
 783         static DECLARE_INTERFACE_USER_FCT(userFctGetBit)
 784         {
 785                 if (args.size() != 2)
 786                         return false;
 787
 788                 if (!args[0].toInteger()) return false;
 789                 if (!args[1].toInteger()) return false;
 790
 791                 sint64 i = args[0].getInteger();
 792                 sint64 s = args[1].getInteger();
 793
 794                 result.setInteger (0);
 795
 796                 if ((i & (SINT64_CONSTANT(1)<<s)) != 0)
 797                         result.setInteger (1);
 798
 799                 return true;
 800         }
 801         REGISTER_INTERFACE_USER_FCT("getbit", userFctGetBit)
 802
 803
 804
 805
 806         // ***********************
 807         // INTERPOLATION FUNCTIONS
 808         // ***********************
 809
 810         //////////////
 811         // i_linear //
 812         //////////////
 813
 814         static DECLARE_INTERFACE_USER_FCT(userFctILinear)
 815         {
 816                 if (args.size() != 3)
 817                         return false;
 818
 819                 if (!args[0].toDouble()) return false;
 820                 if (!args[1].toDouble()) return false;
 821                 if (!args[2].toDouble()) return false;
 822
 823                 double i = args[0].getDouble(); // Interpolant
 824                 double s = args[1].getDouble(); // Start
 825                 double e = args[2].getDouble(); // End
 826
 827                 result.setDouble ( s + i * (e - s) );
 828
 829                 return true;
 830         }
 831         REGISTER_INTERFACE_USER_FCT("ilinear", userFctILinear)
 832
 833
 834
 835         //////////////////
 836         // Bitwise OR   //
 837         //////////////////
 838         static DECLARE_INTERFACE_USER_FCT(userFctBitOr)
 839         {
 840                 uint64  res= 0;
 841                 for(uint k = 0; k < args.size(); ++k)
 842                 {
 843                         if (!args[k].toInteger())
 844                         {
 845                                 nlwarning("Argument is not integer");
 846                                 return false;
 847                         }
 848                         res|= args[k].getInteger();
 849                 }
 850                 result.setInteger(res);
 851                 return true;
 852         }
 853         REGISTER_INTERFACE_USER_FCT("bor", userFctBitOr)
 854
 855         //////////////////
 856         // Bitwise AND  //
 857         //////////////////
 858         static DECLARE_INTERFACE_USER_FCT(userFctBitAnd)
 859         {
 860                 if(args.empty())
 861                 {
 862                         result.setInteger(0);
 863                         return true;
 864                 }
 865
 866                 uint64  res= UINT64_CONSTANT(0xFFFFFFFFFFFFFFFF);
 867                 for(uint k = 0; k < args.size(); ++k)
 868                 {
 869                         if (!args[k].toInteger())
 870                         {
 871                                 nlwarning("Argument is not integer");
 872                                 return false;
 873                         }
 874                         res&= args[k].getInteger();
 875                 }
 876                 result.setInteger(res);
 877                 return true;
 878         }
 879         REGISTER_INTERFACE_USER_FCT("band", userFctBitAnd)
 880
 881         //////////////////
 882         // Bitwise NOT  //
 883         //////////////////
 884         static DECLARE_INTERFACE_USER_FCT(userFctBitNot)
 885         {
 886                 if (args.size() != 1)
 887                 {
 888                         nlwarning("bnot : bad number of arguments");
 889                         return false;
 890                 }
 891                 if (!args[0].toInteger())
 892                 {
 893                         nlwarning("Argument is not integer");
 894                         return false;
 895                 }
 896                 result.setInteger(~args[0].getInteger());
 897                 return true;
 898         }
 899         REGISTER_INTERFACE_USER_FCT("bnot", userFctBitNot)
 900
 901         //////////////////
 902         // Bitwise XOR  //
 903         //////////////////
 904         static DECLARE_INTERFACE_USER_FCT(userFctBitXor)
 905         {
 906                 if (args.size() != 2)
 907                 {
 908                         nlwarning("bxor : bad number of arguments");
 909                         return false;
 910                 }
 911                 if (!args[0].toInteger() || !args[1].toInteger())
 912                 {
 913                         nlwarning("Argument is not integer");
 914                         return false;
 915                 }
 916                 result.setInteger(args[0].getInteger() ^ args[1].getInteger());
 917                 return true;
 918         }
 919         REGISTER_INTERFACE_USER_FCT("bxor", userFctBitXor)
 920
 921         ///////////////////////////
 922         // Unsigned right shift  //
 923         ///////////////////////////
 924         static DECLARE_INTERFACE_USER_FCT(userFctSHR)
 925         {
 926                 if (args.size() != 2)
 927                 {
 928                         nlwarning("shr : bad number of arguments");
 929                         return false;
 930                 }
 931                 if (!args[0].toInteger() || !args[1].toInteger())
 932                 {
 933                         nlwarning("Argument is not integer");
 934                         return false;
 935                 }
 936                 result.setInteger(((uint64)args[0].getInteger()) >> args[1].getInteger());
 937                 return true;
 938         }
 939         REGISTER_INTERFACE_USER_FCT("shr", userFctSHR)
 940
 941         //////////////////////////
 942         // Unsigned left shift  //
 943         //////////////////////////
 944         static DECLARE_INTERFACE_USER_FCT(userFctSHL)
 945         {
 946                 if (args.size() != 2)
 947                 {
 948                         nlwarning("shl : bad number of arguments");
 949                         return false;
 950                 }
 951                 if (!args[0].toInteger() || !args[1].toInteger())
 952                 {
 953                         nlwarning("Argument is not integer");
 954                         return false;
 955                 }
 956                 result.setInteger(((uint64)args[0].getInteger()) << args[1].getInteger());
 957                 return true;
 958         }
 959         REGISTER_INTERFACE_USER_FCT("shl", userFctSHL)
 960
 961         /////////////////////////
 962         // Signed right shift  //
 963         /////////////////////////
 964         static DECLARE_INTERFACE_USER_FCT(userFctSAR)
 965         {
 966                 if (args.size() != 2)
 967                 {
 968                         nlwarning("sar : bad number of arguments");
 969                         return false;
 970                 }
 971                 if (!args[0].toInteger() || !args[1].toInteger())
 972                 {
 973                         nlwarning("Argument is not integer");
 974                         return false;
 975                 }
 976                 result.setInteger(args[0].getInteger() >> args[1].getInteger());
 977                 return true;
 978         }
 979         REGISTER_INTERFACE_USER_FCT("sar", userFctSAR)
 980
 981         ////////////////////////
 982         // Signed left shift  //
 983         ////////////////////////
 984         static DECLARE_INTERFACE_USER_FCT(userFctSAL)
 985         {
 986                 if (args.size() != 2)
 987                 {
 988                         nlwarning("sal : bad number of arguments");
 989                         return false;
 990                 }
 991                 if (!args[0].toInteger() || !args[1].toInteger())
 992                 {
 993                         nlwarning("Argument is not integer");
 994                         return false;
 995                 }
 996                 result.setInteger(args[0].getInteger() << args[1].getInteger());
 997                 return true;
 998         }
 999         REGISTER_INTERFACE_USER_FCT("sal", userFctSAL)
1000
1001         /////////////////////////////////////////////////////////////////////////////
1002         // Extend the sign of the argument considered over 8 bits to a 64 bits int //
1003         /////////////////////////////////////////////////////////////////////////////
1004         static DECLARE_INTERFACE_USER_FCT(extSign8To64)
1005         {
1006                 if (args.size() != 1)
1007                 {
1008                         nlwarning("extSign8To64 : bad number of arguments");
1009                         return false;
1010                 }
1011                 if (!args[0].toInteger())
1012                 {
1013                         nlwarning("Argument is not integer");
1014                         return false;
1015                 }
1016                 sint8 i = (sint8)args[0].getInteger();
1017                 result.setInteger((sint64)i);
1018                 return true;
1019         }
1020         REGISTER_INTERFACE_USER_FCT("extSign8To64", extSign8To64)
1021
1022         //////////////////////////////////////////////////////////////////////////////
1023         // Extend the sign of the argument considered over 11 bits to a 64 bits int //
1024         //////////////////////////////////////////////////////////////////////////////
1025         static DECLARE_INTERFACE_USER_FCT(extSign11To64)
1026         {
1027                 if (args.size() != 1)
1028                 {
1029                         nlwarning("extSign12To64 : bad number of arguments");
1030                         return false;
1031                 }
1032                 if (!args[0].toInteger())
1033                 {
1034                         nlwarning("Argument is not integer");
1035                         return false;
1036                 }
1037                 sint32 i = (sint16)args[0].getInteger() & 0x7ff;
1038                 if( i > 1023 )
1039                         i |= 0xfffff800;
1040                 result.setInteger((sint64)i);
1041                 return true;
1042         }
1043         REGISTER_INTERFACE_USER_FCT("extSign11To64", extSign11To64)
1044
1045         ////////////////////////
1046         // Ryzom version info //
1047         ////////////////////////
1048         static DECLARE_INTERFACE_USER_FCT(isFinalVersion)
1049         {
1050                 if (!args.empty())
1051                 {
1052                         nlwarning("isFinalVersion : no args required");
1053                         return false;
1054                 }
1055                 #if FINAL_VERSION
1056                         result.setBool(true);
1057                 #else
1058                         result.setBool(false);
1059                 #endif
1060                 return true;
1061         }
1062         REGISTER_INTERFACE_USER_FCT("isFinalVersion", isFinalVersion)
1063
1064         ////////////////////////
1065         ////////////////////////
1066         static DECLARE_INTERFACE_USER_FCT(secondsToTimeString)
1067         {
1068                 if (args.size() != 1)
1069                 {
1070                         nlwarning("intToTimeString : 1 args required");
1071                         return false;
1072                 }
1073                 if (!args[0].toInteger())
1074                 {
1075                         nlwarning("intToTimeString : args 0 required to be an int");
1076                         return false;
1077                 }
1078
1079                 sint64 nVal = args[0].getInteger();
1080                 string sTmp;
1081
1082                 if (nVal < 0) nVal = 0;
1083
1084                 sTmp = toString(nVal % 60) + " " + CI18N::get("uiMissionTimerSecond");
1085
1086                 nVal = nVal / 60;
1087
1088                 if( nVal > 0 )
1089                 {
1090                         sTmp = toString(nVal % 60) + " " + CI18N::get("uiMissionTimerMinute") + " " + sTmp;
1091
1092                         nVal = nVal / 60;
1093
1094                         if( nVal > 0 )
1095                         {
1096                                 sTmp = toString(nVal % 24) + " " + CI18N::get("uiMissionTimerHour") + " " + sTmp;
1097
1098                                 nVal = nVal / 24;
1099
1100                                 if( nVal > 0 )
1101                                 {
1102                                         sTmp = toString(nVal) + " " + CI18N::get("uiMissionTimerDay") + " " + sTmp;
1103                                 }
1104                         }
1105                 }
1106
1107                 result.setString(sTmp);
1108
1109                 return true;
1110         }
1111         REGISTER_INTERFACE_USER_FCT("secondsToTimeString", secondsToTimeString)
1112
1113         ////////////////////////
1114         ////////////////////////
1115         static DECLARE_INTERFACE_USER_FCT(secondsToTimeStringShort)
1116         {
1117                 if (args.size() != 1)
1118                 {
1119                         nlwarning("intToTimeString : 1 args required");
1120                         return false;
1121                 }
1122                 if (!args[0].toInteger())
1123                 {
1124                         nlwarning("intToTimeString : args 0 required to be an int");
1125                         return false;
1126                 }
1127
1128                 sint64 nVal = args[0].getInteger();
1129                 string sTmp;
1130
1131                 if (nVal < 0) nVal = 0;
1132
1133                 sTmp = toString("%02d", nVal % 60);
1134
1135                 nVal = nVal / 60;
1136
1137                 if( nVal > 0 )
1138                 {
1139                         sTmp = toString(nVal % 60) + "'" + sTmp;
1140
1141                         nVal = nVal / 60;
1142
1143                         // if at least one hour, just display number of hour
1144                         if( nVal > 0 )
1145                         {
1146                                 sTmp = toString(nVal % 24) + "h";
1147
1148                                 nVal = nVal / 24;
1149
1150                                 // if at least one hour, just display number of days
1151                                 if( nVal > 0 )
1152                                 {
1153                                         sTmp = toString(nVal) + "d";
1154                                 }
1155                         }
1156                 }
1157
1158                 result.setString(sTmp);
1159
1160                 return true;
1161         }
1162         REGISTER_INTERFACE_USER_FCT("secondsToTimeStringShort", secondsToTimeStringShort)
1163
1164         ////////////////////////
1165         ////////////////////////
1166         static DECLARE_INTERFACE_USER_FCT(oldvalue)
1167         {
1168                 if (args.size() != 1)
1169                 {
1170                         nlwarning("oldvalue : 1 arg required");
1171                         return false;
1172                 }
1173                 CCDBNodeLeaf *nl = NLGUI::CDBManager::getInstance()->getDbProp(args[0].getString());
1174                 if (!nl)
1175                 {
1176                         nlwarning("oldvalue : arg 0 required to be an interface leaf");
1177                         return false;
1178                 }
1179                 result.setInteger (nl->getOldValue64());
1180
1181                 return true;
1182         }
1183         REGISTER_INTERFACE_USER_FCT("oldvalue", oldvalue)
1184
1185         ////////////////////////
1186         ////////////////////////
1187         static DECLARE_INTERFACE_USER_FCT(localize)
1188         {
1189                  if (args.size() != 1)
1190                  {
1191                           nlwarning("localize : 1 arg required");
1192                           return false;
1193                  }
1194                  result.setString(CI18N::get(args[0].getString()));
1195                  return true;
1196         }
1197         REGISTER_INTERFACE_USER_FCT("localize", localize);
1198
1199 }
1200