Class: ewol::EObject

Synopsis:

+                                             EObject             (void);
+                                             EObject             (const std::string & _name);
+                                            ~EObject             (void);
+  void                                       removeObject        (void);
+  const char * const                         getObjectType       (void);
+  std::string                                getTypeDescription  (void);
+  bool                                       isTypeCompatible    (const std::string & _type);
+  bool                                       getStatic           (void);
+  int32_t                                    getId               (void);
+  void                                       registerOnEvent     (ewol::EObject * _destinationObject,
                                                                   const char * _eventId,
                                                                   const char * _eventIdgenerated,
                                                                   const std::string & _overloadData);
+  void                                       unRegisterOnEvent   (ewol::EObject * _destinationObject,
                                                                   const char * _eventId);
+  void                                       onObjectRemove      (ewol::EObject * _removeObject);
+  void                                       onReceiveMessage    (const ewol::EMessage & _msg);
+  const std::vector &  getConfigList       (void);
+  bool                                       setConfig           (const ewol::EConfig & _conf);
+  bool                                       setConfig           (const std::string & _config,
                                                                   const std::string & _value);
+  bool                                       setConfigNamed      (const std::string & _objectName,
                                                                   const std::string & _config,
                                                                   const std::string & _value);
+  bool                                       setConfigNamed      (const std::string & _objectName,
                                                                   const ewol::EConfig & _conf);
+  std::string                                getConfig           (const char * _config);
+  std::string                                getConfig           (const std::string & _config);
+  const std::string &                        getName             (void);
+  void                                       setName             (const std::string & _name);
+  bool                                       loadXML             (exml::Element * _node);
+  bool                                       storeXML            (exml::Element * _node);
+  ewol::EObjectManager &                     getEObjectManager   (void);
+  ewol::EMultiCast &                         getMultiCast        (void);
+  eContext &                                 getContext          (void);
+  void                                       setStatusResource   (bool _val);
+  bool                                       getStatusResource   (void);
#  void                                       autoDestroy         (void);
#  void                                       addObjectType       (const char * _type);
#  void                                       addEventId          (const char * _generateEventId);
#  void                                       generateEventId     (const char * _generateEventId,
                                                                   const std::string & _data);
#  void                                       sendMultiCast       (const char * const _messageId,
                                                                   const std::string & _data);
#  void                                       registerMultiCast   (const char * const _messageId);
#  void                                       registerConfig      (const char * _config,
                                                                   const char * _type,
                                                                   const char * _control,
                                                                   const char * _description,
                                                                   const char * _default);
#  bool                                       onSetConfig         (const ewol::EConfig & _conf);
#  bool                                       onGetConfig         (const char * _config,
                                                                   std::string & _result);

Object Hierarchy:

ewol::EObject
    +--> ewol::Widget
    +--> ewol::Resource

Description:

//!< sometimes the user prefer to receive some specific data on an event (instead of the one sed by the widget)/** * @brief Basic message classes for ewol system * this class mermit at every EObject to communicate between them. */

Detail:

ewol::EObject ()

EObject(void);

Constructor.

---

ewol::EObject ()

EObject(const std::string & _name);

Constructor.

Parameter [input]: _name Name of the EObject.

---

ewol::~EObject ()

~EObject(void);

Destructor

---

removeObject ()

void removeObject(void);

Asynchronous removing the object

---

getObjectType ()

const char * const getObjectType(void);

get the current Object type of the EObject

Return: the last type name of the element

---

getTypeDescription ()

std::string getTypeDescription(void);

Get the herarchie of the EObject type.

Return: descriptive string.

---

isTypeCompatible ()

bool isTypeCompatible(const std::string & _type);

check if the element herited from a specific type

Parameter [input]: _type Type to check.
Return: true if the element is compatible.

---

getStatic ()

bool getStatic(void);

get the static status of the EObject == > mark at true if the user set the object mark as static allocated element ==> not auto remove element

Return: true if it might not be removed == > usefull for conficuration class

---

getId ()

int32_t getId(void);

get the UniqueId of the EObject

Return: the requested ID

---

registerOnEvent ()

void registerOnEvent(ewol::EObject * _destinationObject,
                     const char * _eventId,
                     const char * _eventIdgenerated,
                     const std::string & _overloadData);

Register an EObject over an other to get event on the second...

Parameter [input]: _destinationObject pointer on the object that might be call when an event is generated
Parameter [input]: _eventId Event generate inside the object
Parameter [input]: _eventIdgenerated event generated when call the distant EObject.onReceiveMessage(...)
Parameter [input]: _overloadData When the user prever to receive a data specificly for this event ...

---

unRegisterOnEvent ()

void unRegisterOnEvent(ewol::EObject * _destinationObject,
                       const char * _eventId);

Un-Register an EObject over an other.

Parameter [input]: _destinationObject pointer on the object that might be call when an event is generated
Parameter [input]: _eventId Event generate inside the object (NULL to remove all event on this object)

---

onObjectRemove ()

void onObjectRemove(ewol::EObject * _removeObject);

Inform object that an other object is removed ...
Notes: : Sub classes must call this class

Parameter [input]: _removeObject Pointer on the EObject remeved == > the user must remove all reference on this EObject

---

onReceiveMessage ()

void onReceiveMessage(const ewol::EMessage & _msg);

Receive a message from an other EObject with a specific eventId and data

Parameter [input]: _msg Message handle

---

getConfigList ()

const std::vector & getConfigList(void);

get all the configuration list

Return: The list of all parameter availlable in the widget

---

setConfig ()

bool setConfig(const ewol::EConfig & _conf);

Configuration requested to the curent EObject (systrem mode)

Parameter [input]: _conf Configuration handle.
Return: true if config set correctly...

---

setConfig ()

bool setConfig(const std::string & _config,
               const std::string & _value);

---

setConfigNamed ()

bool setConfigNamed(const std::string & _objectName,
                    const std::string & _config,
                    const std::string & _value);

---

setConfigNamed ()

bool setConfigNamed(const std::string & _objectName,
                    const ewol::EConfig & _conf);

---

getConfig ()

std::string getConfig(const char * _config);

Configuration get from the curent EObject (systrem mode)

Parameter [input]: _config Configuration name.
Return: the config properties

---

getConfig ()

std::string getConfig(const std::string & _config);

---

getName ()

const std::string & getName(void);

get the eObject name

Return: The requested name

---

setName ()

void setName(const std::string & _name);

get the Widget name

Parameter [input]: _name The new name

---

loadXML ()

bool loadXML(exml::Element * _node);

load properties with an XML node.

Parameter [input]: _node Pointer on the tinyXML node.
Return: true : All has been done corectly.
Return: false : An error occured.

---

storeXML ()

bool storeXML(exml::Element * _node);

store properties in this XML node.

Parameter [input] [output]: _node Pointer on the tinyXML node.
Return: true : All has been done corectly.
Return: false : An error occured.

---

getEObjectManager ()

ewol::EObjectManager & getEObjectManager(void);

Return: the requested object manager.

---

getMultiCast ()

ewol::EMultiCast & getMultiCast(void);

Return: the requested object manager.

---

getContext ()

eContext & getContext(void);

get the curent the system inteface.

Return: current reference on the instance.

---

setStatusResource ()

void setStatusResource(bool _val);

Declare this element as a resource (or singleton) this mean the element will not be auto Remove at the end of the programm. It just notify that it is not removed.

Parameter [input]: _val Value of the type of the element.

---

getStatusResource ()

bool getStatusResource(void);

Get the resource status of the element.

Return: the resource status.

---

autoDestroy ()

void autoDestroy(void);

Auto-destroy the object

---

addObjectType ()

void addObjectType(const char * _type);

Add a type of the list of eObject.

Parameter [input]: _type new type to add.

---

addEventId ()

void addEventId(const char * _generateEventId);

add a specific event Id in the list to prevent wrong link on a EObject

Parameter [input]: _generateEventId event Id to add

---

generateEventId ()

void generateEventId(const char * _generateEventId,
                     const std::string & _data);

generate event on all registered EObject

Parameter [input]: _generateEventId event Id that is curetly generated
Parameter [input]: _data data associated with the event

---

sendMultiCast ()

void sendMultiCast(const char * const _messageId,
                   const std::string & _data);

generate Multicast event on all EObject requested the event

Parameter [input]: _messageId Event Id that is generated
Parameter [input]: _data String that is send at all the destinations

---

registerMultiCast ()

void registerMultiCast(const char * const _messageId);

Register of the arrival of a Multicast message

Parameter [input]: _messageId Event Id waiting for...

---

registerConfig ()

void registerConfig(const char * _config,
                    const char * _type,
                    const char * _control,
                    const char * _description,
                    const char * _default);

the EObject add a configuration capabilities

Parameter [input]: _config Configuration name.
Parameter [input]: _type Type of the config.
Parameter [input]: _control control of the current type.
Parameter [input]: _description Descritpion on the current type.
Parameter [input]: _default Default value of this parameter.

---

onSetConfig ()

bool onSetConfig(const ewol::EConfig & _conf);

Configuration requested to the curent EObject

Parameter [input]: _conf Configuration handle.
Return: true if the parametere has been used

---

onGetConfig ()

bool onGetConfig(const char * _config,
                 std::string & _result);

Receive a configuration message from an other element system or from the curent EObject

Parameter [input]: _config Configuration name.
Parameter [output]: _result Result of the request.
Return: true if the config is set

---