181 lines
4.6 KiB
C
181 lines
4.6 KiB
C
/*
|
|
* File : rtgui_object.c
|
|
* This file is part of RTGUI in RT-Thread RTOS
|
|
* COPYRIGHT (C) 2006 - 2009, RT-Thread Development Team
|
|
*
|
|
* The license and distribution terms for this file may be
|
|
* found in the file LICENSE in this distribution or at
|
|
* http://www.rt-thread.org/license/LICENSE
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2009-10-04 Bernard first version
|
|
*/
|
|
|
|
#include <rtgui/rtgui_object.h>
|
|
#include <rtgui/rtgui_system.h>
|
|
|
|
static void _rtgui_object_constructor(rtgui_object_t *object)
|
|
{
|
|
if (!object) return;
|
|
|
|
object->is_static = RT_FALSE;
|
|
}
|
|
|
|
/* Destroys the object */
|
|
static void _rtgui_object_destructor(rtgui_object_t *object)
|
|
{
|
|
/* nothing */
|
|
}
|
|
|
|
DEFINE_CLASS_TYPE(type, "object",
|
|
RT_NULL,
|
|
_rtgui_object_constructor,
|
|
_rtgui_object_destructor,
|
|
sizeof(struct rtgui_object));
|
|
|
|
void rtgui_type_object_construct(const rtgui_type_t *type, rtgui_object_t *object)
|
|
{
|
|
/* first call parent's type */
|
|
if (type->parent != RT_NULL)
|
|
rtgui_type_object_construct(type->parent, object);
|
|
|
|
if (type->constructor) type->constructor(object);
|
|
}
|
|
|
|
void rtgui_type_destructors_call(const rtgui_type_t *type, rtgui_object_t *object)
|
|
{
|
|
const rtgui_type_t *t;
|
|
|
|
t = type;
|
|
while (t)
|
|
{
|
|
if (t->destructor) t->destructor(object);
|
|
t = t->parent;
|
|
}
|
|
}
|
|
|
|
rt_bool_t rtgui_type_inherits_from(const rtgui_type_t *type, const rtgui_type_t *parent)
|
|
{
|
|
const rtgui_type_t *t;
|
|
|
|
t = type;
|
|
while (t)
|
|
{
|
|
if (t == parent) return RT_TRUE;
|
|
t = t->parent;
|
|
}
|
|
|
|
return RT_FALSE;
|
|
}
|
|
|
|
const rtgui_type_t *rtgui_type_parent_type_get(const rtgui_type_t *type)
|
|
{
|
|
return type->parent;
|
|
}
|
|
|
|
const char *rtgui_type_name_get(const rtgui_type_t *type)
|
|
{
|
|
if (!type) return RT_NULL;
|
|
|
|
return type->name;
|
|
}
|
|
|
|
#ifdef RTGUI_OBJECT_TRACE
|
|
struct rtgui_object_information
|
|
{
|
|
rt_uint32_t objs_number;
|
|
rt_uint32_t allocated_size;
|
|
rt_uint32_t max_allocated;
|
|
};
|
|
struct rtgui_object_information obj_info = {0, 0, 0};
|
|
#endif
|
|
|
|
/**
|
|
* @brief Creates a new object: it calls the corresponding constructors (from the constructor of the base class to the
|
|
* constructor of the more derived class) and then sets the values of the given properties
|
|
* @param object_type the type of object to create
|
|
* @return Returns the new Etk_Object of type @a object_type
|
|
*/
|
|
rtgui_object_t *rtgui_object_create(rtgui_type_t *object_type)
|
|
{
|
|
rtgui_object_t *new_object;
|
|
|
|
if (!object_type)
|
|
return RT_NULL;
|
|
|
|
new_object = rtgui_malloc(object_type->size);
|
|
if (new_object == RT_NULL) return RT_NULL;
|
|
|
|
#ifdef RTGUI_OBJECT_TRACE
|
|
obj_info.objs_number ++;
|
|
obj_info.allocated_size += object_type->size;
|
|
if (obj_info.allocated_size > obj_info.max_allocated)
|
|
obj_info.max_allocated = obj_info.allocated_size;
|
|
#endif
|
|
|
|
new_object->type = object_type;
|
|
new_object->is_static = RT_FALSE;
|
|
|
|
rtgui_type_object_construct(object_type, new_object);
|
|
|
|
return new_object;
|
|
}
|
|
|
|
/**
|
|
* @brief Destroys the object: it first sets the weak-pointers to RT_NULL, emits the "destroyed" signal, and then
|
|
* queues the object in the list of objects to free. Thus, the destructors will only be called at the beginning of the
|
|
* next main loop iteration (from the destructor of the more derived class to the destructor of the ultimate base class).
|
|
* @param object the object to destroy
|
|
* @warning You should not assume that this function will call directly the destructors of the object!
|
|
*/
|
|
void rtgui_object_destroy(rtgui_object_t *object)
|
|
{
|
|
if (!object || object->is_static == RT_TRUE) return;
|
|
|
|
#ifdef RTGUI_OBJECT_TRACE
|
|
obj_info.objs_number --;
|
|
obj_info.allocated_size -= object->type->size;
|
|
#endif
|
|
|
|
/* call destructor */
|
|
RT_ASSERT(object->type != RT_NULL);
|
|
rtgui_type_destructors_call(object->type, object);
|
|
|
|
/* release object */
|
|
rtgui_free(object);
|
|
}
|
|
|
|
/**
|
|
* @brief Checks if @a object can be cast to @a type.
|
|
* If @a object doesn't inherit from @a type, a warning is displayed in the console but the object is returned anyway.
|
|
* @param object the object to cast
|
|
* @param type the type to which we cast the object
|
|
* @return Returns the object
|
|
* @note You usually do not need to call this function, use specific macros instead (ETK_IS_WIDGET() for example)
|
|
*/
|
|
rtgui_object_t *rtgui_object_check_cast(rtgui_object_t *obj, rtgui_type_t *obj_type)
|
|
{
|
|
if (!obj) return RT_NULL;
|
|
|
|
if (!rtgui_type_inherits_from(obj->type, obj_type))
|
|
{
|
|
rt_kprintf("Invalid cast from \"%s\" to \"%s\"\n", rtgui_type_name_get(obj->type), rtgui_type_name_get(obj_type));
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the type of the object
|
|
* @param object an object
|
|
* @return Returns the type of @a object (RT_NULL on failure)
|
|
*/
|
|
const rtgui_type_t *rtgui_object_object_type_get(rtgui_object_t *object)
|
|
{
|
|
if (!object) return RT_NULL;
|
|
|
|
return object->type;
|
|
}
|
|
|