673 lines
23 KiB
C++
673 lines
23 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// 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/>.
|
|
|
|
#ifndef NL_FORM_ELM_H
|
|
#define NL_FORM_ELM_H
|
|
|
|
#include "nel/georges/u_form_elm.h"
|
|
#include "nel/misc/smart_ptr.h"
|
|
#include "nel/misc/rgba.h"
|
|
|
|
#include "form_dfn.h"
|
|
|
|
#define NLGEORGES_FIRST_ROUND 0
|
|
#define NLGEORGES_MAX_RECURSION 100
|
|
|
|
namespace NLGEORGES
|
|
{
|
|
|
|
class CType;
|
|
class CFormDfn;
|
|
class CForm;
|
|
|
|
/**
|
|
* Base class of form elements
|
|
*/
|
|
class CFormElm : public UFormElm
|
|
{
|
|
friend class CForm;
|
|
friend class CType;
|
|
friend class CFormDfn;
|
|
public:
|
|
|
|
// Contructor
|
|
CFormElm (CForm *form, CFormElm *parentNode, const CFormDfn *parentDfn, uint parentIndex);
|
|
|
|
// Destructor
|
|
virtual ~CFormElm ();
|
|
|
|
/// Reset contents
|
|
virtual void clean() {}
|
|
|
|
// Get the form pointer
|
|
CForm *getForm () const;
|
|
|
|
// Is the element used by this form ?
|
|
virtual bool isUsed (const CForm *form) const;
|
|
|
|
// Get the form name of the element
|
|
virtual void getFormName (std::string &result, const CFormElm *child=NULL) const = 0;
|
|
|
|
// From UFormElm
|
|
virtual bool getNodeByName (const UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round=0) const;
|
|
virtual bool getNodeByName (UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round=0);
|
|
virtual bool getValueByName (std::string &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (sint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (uint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (sint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (uint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (sint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (uint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (float &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (double &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (bool &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool getValueByName (NLMISC::CRGBA &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
|
|
virtual bool setValueByName (const char *value, const char *name, bool *created);
|
|
virtual bool setValueByName (sint8 value, const char *name, bool *created);
|
|
virtual bool setValueByName (uint8 value, const char *name, bool *created);
|
|
virtual bool setValueByName (sint16 value, const char *name, bool *created);
|
|
virtual bool setValueByName (uint16 value, const char *name, bool *created);
|
|
virtual bool setValueByName (sint32 value, const char *name, bool *created);
|
|
virtual bool setValueByName (uint32 value, const char *name, bool *created);
|
|
virtual bool setValueByName (float value, const char *name, bool *created);
|
|
virtual bool setValueByName (double value, const char *name, bool *created);
|
|
virtual bool setValueByName (bool value, const char *name, bool *created);
|
|
virtual bool setValueByName (NLMISC::CRGBA value, const char *name, bool *created);
|
|
virtual UFormElm *getParent () const;
|
|
virtual const CType *getType ();
|
|
virtual bool isArray () const;
|
|
virtual bool getArraySize (uint &size) const;
|
|
virtual bool getArrayNode (const UFormElm **result, uint arrayIndex) const;
|
|
virtual bool getArrayNode (UFormElm **result, uint arrayIndex);
|
|
virtual bool getArrayNodeName (std::string &result, uint arrayIndex) const;
|
|
virtual bool getArrayValue (std::string &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (sint8 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (uint8 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (sint16 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (uint16 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (sint32 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (uint32 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (float &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (double &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (bool &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
virtual bool isStruct () const;
|
|
virtual bool isVirtualStruct () const;
|
|
virtual bool getDfnName (std::string &dfnName ) const;
|
|
virtual bool getStructSize (uint &size) const;
|
|
virtual bool getStructNodeName (uint element, std::string &result) const;
|
|
virtual bool getStructNode (uint element, const UFormElm **result) const;
|
|
virtual bool getStructNode (uint element, UFormElm **result);
|
|
virtual bool isAtom () const;
|
|
virtual bool getValue (std::string &resultname, TEval evaluate) const;
|
|
virtual bool getValue (sint8 &resultname, TEval evaluate) const;
|
|
virtual bool getValue (uint8 &resultname, TEval evaluate) const;
|
|
virtual bool getValue (sint16 &resultname, TEval evaluate) const;
|
|
virtual bool getValue (uint16 &resultname, TEval evaluate) const;
|
|
virtual bool getValue (sint32 &resultname, TEval evaluate) const;
|
|
virtual bool getValue (uint32 &resultname, TEval evaluate) const;
|
|
virtual bool getValue (float &resultname, TEval evaluate) const;
|
|
virtual bool getValue (double &resultname, TEval evaluate) const;
|
|
virtual bool getValue (bool &resultname, TEval evaluate) const;
|
|
virtual bool getValue (NLMISC::CRGBA &resultname, TEval evaluate) const;
|
|
virtual UFormDfn *getStructDfn () { return NULL; }
|
|
|
|
// ** Convert functions
|
|
|
|
inline bool convertValue (sint8 &result, const char *value) const;
|
|
inline bool convertValue (uint8 &result, const char *value) const;
|
|
inline bool convertValue (sint16 &result, const char *value) const;
|
|
inline bool convertValue (uint16 &result, const char *value) const;
|
|
inline bool convertValue (sint32 &result, const char *value) const;
|
|
inline bool convertValue (uint32 &result, const char *value) const;
|
|
inline bool convertValue (float &result, const char *value) const;
|
|
inline bool convertValue (double &result, const char *value) const;
|
|
inline bool convertValue (bool &result, const char *value) const;
|
|
inline bool convertValue (NLMISC::CRGBA &result, const char *value) const;
|
|
|
|
// ** Get dependencies
|
|
virtual void getDependencies (std::set<std::string> &dependencies) const = 0;
|
|
|
|
// ** Internal node access
|
|
|
|
// Create a node by name. If the node already exists, return it
|
|
bool createNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn,
|
|
const CFormDfn **nodeDfn, const CType **nodeType,
|
|
CFormElm **node, UFormDfn::TEntryType &type,
|
|
bool &array, bool &created);
|
|
|
|
/**
|
|
* Delete a node by name. If the node already exists, return it
|
|
*Delete its parent if not used
|
|
*/
|
|
bool deleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn,
|
|
const CFormDfn **nodeDfn, const CType **nodeType,
|
|
CFormElm **node, UFormDfn::TEntryType &type,
|
|
bool &array);
|
|
|
|
// Search for a node by name
|
|
bool getNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn,
|
|
const CFormDfn **nodeDfn, const CType **nodeType,
|
|
CFormElm **node, UFormDfn::TEntryType &type,
|
|
bool &array, bool &parentVDfnArray, bool verbose, uint32 round) const;
|
|
|
|
/**
|
|
* Insert an array node by name
|
|
* The index asked must be < the size of the array.
|
|
*/
|
|
bool arrayInsertNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn,
|
|
const CFormDfn **nodeDfn, const CType **nodeType,
|
|
CFormElm **node, UFormDfn::TEntryType &type,
|
|
bool &array, bool verbose, uint arrayIndex) const;
|
|
|
|
/**
|
|
* Delete an array node by name
|
|
* The index asked must be < the size of the array.
|
|
*/
|
|
bool arrayDeleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn,
|
|
const CFormDfn **nodeDfn, const CType **nodeType,
|
|
CFormElm **node, UFormDfn::TEntryType &type,
|
|
bool &array, bool verbose, uint arrayIndex) const;
|
|
protected:
|
|
|
|
// Action to perform
|
|
enum TNodeAction
|
|
{
|
|
Return,
|
|
Create,
|
|
Delete,
|
|
};
|
|
|
|
/**
|
|
* Is createNode == Create, (*node)->Form must be == to the form argument.
|
|
* Is createNode == Return, form argument is not used, can be undefined.
|
|
*
|
|
* Only form, name, and action, must be defined.
|
|
* Then, else (*parentDfn / indexDfn ) or *node must be defined.
|
|
* Other values are for result only.
|
|
*/
|
|
static bool getInternalNodeByName (CForm *form, const char *name, const CFormDfn **parentDfn, uint &indexDfn,
|
|
const CFormDfn **nodeDfn, const CType **nodeType,
|
|
CFormElm **node, UFormDfn::TEntryType &type,
|
|
bool &array, TNodeAction action, bool &created, bool &parentVDfnArray, bool verbose, uint32 round);
|
|
|
|
/**
|
|
* Unlink a child
|
|
*/
|
|
virtual void unlink (CFormElm *child);
|
|
|
|
public:
|
|
|
|
// Get next token, return NULL if last token
|
|
static const char* tokenize (const char *name, std::string &str, uint &errorIndex, uint &code);
|
|
|
|
// ** IO functions
|
|
virtual xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName = NULL, bool forceWrite = false) const = 0;
|
|
|
|
protected:
|
|
|
|
// The form of this node
|
|
CForm *Form;
|
|
|
|
// The parent node of this node
|
|
CFormElm *ParentNode;
|
|
|
|
// The parent DFN of this node
|
|
const CFormDfn *ParentDfn;
|
|
|
|
// The index in the parent DFN for this node
|
|
uint ParentIndex;
|
|
|
|
// Recurce Tag
|
|
uint32 Round;
|
|
|
|
// Error handling
|
|
static void warning (bool exception, const char *formName, const char *formFileName, const char *function, const char *format, ... );
|
|
virtual void warning (bool exception, const char *function, const char *format, ... ) const;
|
|
|
|
private:
|
|
// Tokens
|
|
enum TToken
|
|
{
|
|
TokenString = 0,
|
|
TokenPoint,
|
|
TokenArrayBegin,
|
|
TokenArrayEnd,
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Define a structure of elements
|
|
*
|
|
* This structure has pointers on named sub structures in Elements.
|
|
* If a sub structure is empty, its pointer is NULL.
|
|
*/
|
|
class CFormElmStruct : public CFormElm
|
|
{
|
|
public:
|
|
// Default constructor
|
|
CFormElmStruct (CForm *form, CFormElm *parentNode, const CFormDfn *parentDfn, uint parentIndex);
|
|
virtual ~CFormElmStruct ();
|
|
|
|
// Clear sub elements
|
|
void clean ();
|
|
|
|
// Smart pointer on the form definition for this structure
|
|
NLMISC::CSmartPtr<CFormDfn> FormDfn;
|
|
|
|
// Pointer on the parent element
|
|
//CFormElmStruct *Parent;
|
|
|
|
// A struct element
|
|
class CFormElmStructElm
|
|
{
|
|
public:
|
|
CFormElmStructElm ()
|
|
{
|
|
Element = NULL;
|
|
}
|
|
|
|
std::string Name;
|
|
CFormElm* Element;
|
|
};
|
|
|
|
|
|
// Build form a DFN
|
|
void build (const CFormDfn *dfn);
|
|
|
|
// From UFormElm
|
|
bool isStruct () const;
|
|
bool getStructSize (uint &size) const;
|
|
bool getStructNodeName (uint element, std::string &result) const;
|
|
bool getStructNode (uint element, const UFormElm **result) const;
|
|
bool getStructNode (uint element, UFormElm **result);
|
|
UFormDfn *getStructDfn ();
|
|
|
|
// From CFormElm
|
|
bool isUsed (const CForm *form) const;
|
|
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const;
|
|
void unlink (CFormElm *child);
|
|
void getFormName (std::string &result, const CFormElm *child) const;
|
|
void getDependencies (std::set<std::string> &dependencies) const;
|
|
|
|
// Call by CFormLoader
|
|
void read (xmlNodePtr node, CFormLoader &loader, const CFormDfn *dfn, CForm *form);
|
|
|
|
// Sub Elements
|
|
std::vector<CFormElmStructElm> Elements;
|
|
|
|
// Error handling
|
|
virtual void warning (bool exception, const char *function, const char *format, ... ) const;
|
|
};
|
|
|
|
/**
|
|
* Define an array of elements
|
|
*/
|
|
class CFormElmVirtualStruct : public CFormElmStruct
|
|
{
|
|
public:
|
|
|
|
CFormElmVirtualStruct (CForm *form, CFormElm *parentNode, const CFormDfn *parentDfn, uint parentIndex);
|
|
virtual ~CFormElmVirtualStruct() { }
|
|
|
|
// The Dfn filename used by this struct
|
|
std::string DfnFilename;
|
|
|
|
// From UFormElm
|
|
bool isVirtualStruct () const;
|
|
bool getDfnName (std::string &dfnName ) const;
|
|
|
|
// From CFormElm
|
|
bool isUsed (const CForm *form) const;
|
|
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const;
|
|
|
|
// Call by CFormLoader
|
|
void read (xmlNodePtr node, CFormLoader &loader, CForm *form);
|
|
|
|
// Error handling
|
|
virtual void warning (bool exception, const char *function, const char *format, ... ) const;
|
|
};
|
|
|
|
/**
|
|
* Define an array of elements
|
|
*/
|
|
class CFormElmArray : public CFormElm
|
|
{
|
|
public:
|
|
// Default constructor
|
|
CFormElmArray (CForm *form, const CFormDfn *formDfn, const CType *type, CFormElm *parentNode, const CFormDfn *parentDfn, uint parentIndex);
|
|
virtual ~CFormElmArray ();
|
|
void clean ();
|
|
|
|
// Smart pointer on the form definition for this structure
|
|
NLMISC::CSmartPtr<CFormDfn> FormDfn;
|
|
|
|
// Pointer on the type (the smart pointer in hold by CFormDfn)
|
|
const CType *Type;
|
|
|
|
// From UFormElm
|
|
bool isArray () const;
|
|
bool getArraySize (uint &size) const;
|
|
bool getArrayNode (const UFormElm **result, uint arrayIndex) const;
|
|
bool getArrayNode (UFormElm **result, uint arrayIndex);
|
|
bool getArrayNodeName (std::string &result, uint arrayIndex) const;
|
|
bool getArrayValue (std::string &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (sint8 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (uint8 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (sint16 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (uint16 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (sint32 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (uint32 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (float &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (double &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (bool &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
bool getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
|
|
|
|
// From CFormElm
|
|
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const;
|
|
bool setParent (CFormElm *parent);
|
|
void unlink (CFormElm *child);
|
|
bool isUsed (const CForm *form) const;
|
|
void getFormName (std::string &result, const CFormElm *child) const;
|
|
void getDependencies (std::set<std::string> &dependencies) const;
|
|
|
|
// Call by CFormLoader
|
|
|
|
// Read an array
|
|
void read (xmlNodePtr node, CFormLoader &loader, CForm *form);
|
|
|
|
// A struct element
|
|
class CElement
|
|
{
|
|
public:
|
|
CElement ()
|
|
{
|
|
Element = NULL;
|
|
}
|
|
|
|
std::string Name;
|
|
CFormElm* Element;
|
|
};
|
|
|
|
// Array of elements
|
|
std::vector<CElement> Elements;
|
|
|
|
// Error handling
|
|
virtual void warning (bool exception, const char *function, const char *format, ... ) const;
|
|
};
|
|
|
|
/**
|
|
* Signed integer element
|
|
*/
|
|
class CFormElmAtom : public CFormElm
|
|
{
|
|
friend class CForm;
|
|
friend class CFormElm;
|
|
friend class CType;
|
|
public:
|
|
// Default constructor
|
|
CFormElmAtom (CForm *form, CFormElm *parentNode, const CFormDfn *parentDfn, uint parentIndex);
|
|
virtual ~CFormElmAtom() { }
|
|
|
|
// Pointer on the parent element
|
|
//CFormElmAtom *Parent;
|
|
|
|
// Pointer on the type (the smart pointer in hold by CFormDfn)
|
|
const CType *Type;
|
|
|
|
// From CFormElm
|
|
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const;
|
|
bool setParent (CFormElm *parent);
|
|
void getFormName (std::string &result, const CFormElm *child) const;
|
|
void getDependencies (std::set<std::string> &dependencies) const;
|
|
const CType* getType ();
|
|
|
|
// Call by CFormLoader
|
|
void read (xmlNodePtr node, CFormLoader &loader, const CType *type, CForm *form);
|
|
|
|
// From UFormElm
|
|
bool isAtom () const;
|
|
bool getValue (std::string &resultname, TEval evaluate) const;
|
|
bool getValue (sint8 &resultname, TEval evaluate) const;
|
|
bool getValue (uint8 &resultname, TEval evaluate) const;
|
|
bool getValue (sint16 &resultname, TEval evaluate) const;
|
|
bool getValue (uint16 &resultname, TEval evaluate) const;
|
|
bool getValue (sint32 &resultname, TEval evaluate) const;
|
|
bool getValue (uint32 &resultname, TEval evaluate) const;
|
|
bool getValue (float &resultname, TEval evaluate) const;
|
|
bool getValue (double &resultname, TEval evaluate) const;
|
|
bool getValue (bool &resultname, TEval evaluate) const;
|
|
bool getValue (NLMISC::CRGBA &resultname, TEval evaluate) const;
|
|
|
|
// Set the value, the elt been used
|
|
void setValue (const char *value);
|
|
|
|
private:
|
|
// The value
|
|
std::string Value;
|
|
|
|
// Error handling
|
|
virtual void warning (bool exception, const char *function, const char *format, ... ) const;
|
|
};
|
|
|
|
// ***************************************************************************
|
|
// CFormElm inlines
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (sint8 &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
NLMISC::clamp (tmp, -128.f, 127.f);
|
|
result = (sint8)tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in sint8.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (uint8 &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
NLMISC::clamp (tmp, 0.f, 255.f);
|
|
result = (uint8)tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in uint8.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (sint16 &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
NLMISC::clamp (tmp, -32768.f, 32767.f);
|
|
result = (sint16)tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in sint16.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (uint16 &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
NLMISC::clamp (tmp, 0.f, 65535.f);
|
|
result = (uint16)tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in uint16.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (sint32 &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
NLMISC::clamp (tmp, -2147483648.f, 2147483647.f);
|
|
result = (sint32)tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in sint32.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (uint32 &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
NLMISC::clamp (tmp, 0.f, 4294967295.f);
|
|
result = (sint32)tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in uint32.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (float &result, const char *value) const
|
|
{
|
|
if (NLMISC::fromString(value, result))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in float.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (double &result, const char *value) const
|
|
{
|
|
float tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
result = tmp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in double.", value);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (bool &result, const char *value) const
|
|
{
|
|
int tmp;
|
|
if (NLMISC::fromString(value, tmp))
|
|
{
|
|
result = tmp != 0;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
std::string temp = NLMISC::toLower(std::string(value));
|
|
if (strcmp (temp.c_str (), "true") == 0)
|
|
{
|
|
result = true;
|
|
return true;
|
|
}
|
|
if (strcmp (temp.c_str (), "false") == 0)
|
|
{
|
|
result = false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in boolean.", value);
|
|
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
inline bool CFormElm::convertValue (NLMISC::CRGBA &result, const char *value) const
|
|
{
|
|
float r, g, b;
|
|
if (sscanf (value, "%f,%f,%f", &r, &g, &b) == 3)
|
|
{
|
|
NLMISC::clamp (r, 0.f, 255.f);
|
|
NLMISC::clamp (g, 0.f, 255.f);
|
|
NLMISC::clamp (b, 0.f, 255.f);
|
|
result.R = (uint8)r;
|
|
result.G = (uint8)g;
|
|
result.B = (uint8)b;
|
|
return true;
|
|
}
|
|
|
|
// Error message
|
|
warning (false, "convertValue", "Can't convert the string \"%s\" in RGB color.", value);
|
|
|
|
return false;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
|
|
} // NLGEORGES
|
|
|
|
#endif // NL_FORM_ELM_H
|