如何将GTK+-2.0的信号、回调处理映射成OOC虚拟成员函数的调用
#ifndef __OBJECT_ORIENTED_C__
#define __OBJECT_ORIENTED_C__
#ifdef __cplusplus
extern "C" {
#endif
/* ======================================================================== */
/* 这一区块定义下面用到的一些名字组成宏 */
/* 类方法名字拼接 */
#define METHOD(class, method) class##_##method
/* 类方法的类型的名字拼接 */
#define METHOD_TYPE(class, method) __##class##_##method##_typedef__
/* 类的虚函数表结构的名字拼接 */
#define VTBL_STRU_NAME(class) __##class##_v_func_tbl__
/* 类的虚函数在虚函数表中的位置的名字拼接 */
#define VTBL_FUNC_PTR_NAME(class, func) __##class##_fp_##func##_offset__
/* 类的虚函数表实体的名字拼接 */
#define VTBL_ENTITY_NAME(class) __##class##_vtable_array__
/* 类的虚函数表实体初始化函数的名字拼接 */
#define VTBL_ENTITY_INIT_METHOD(class) __##class##_class_vtable_init__
/* 类的虚函数表实体是否初始化OK的名字拼接 */
#define VTBL_ENTITY_IS_INIT_FLAG(class) __##class##_class_vtable_is_init__
/* 类的虚函数表实体初始化结构变量的名字拼接 */
#define VTBL_ENTITY_INIT_STRU_VAR(class) class##_class_vtable_init_info
/* 获取类的虚函数表初始化函数的指针 */
#define VTBL_ENTITY_INIT_METHOD_PTR(class) ( VTBL_ENTITY_INIT_STRU_VAR(class) . vtable_init_method)
/* ======================================================================== */
/* ======================================================================== */
/* 创建接口 */
#define new(class) METHOD(class, create)()
/* 释放接口 */
#define delete(class, object) METHOD(class, destory)(object)
/* ======================================================================== */
/* ======================================================================== */
/* 类声明的开始宏 */
#define BEGIN_CLASS(class) \
struct class; \
typedef struct class class; \
struct VTBL_STRU_NAME(class); \
extern class_vtable_init VTBL_ENTITY_INIT_STRU_VAR(class); \
class * METHOD(class, create)(void); \
int METHOD(class, constructor)(class* this); \
void METHOD(class, destory)(class* this); \
int METHOD(class, destructor)(class* this); \
struct class
/* 继承自父类的声明 */
#define INHERITED_PARENT(p_class) \
p_class parent
/* 类中的虚函数声明开始宏 */
#define BEGIN_V_METHOD_DEFINE(class) \
struct VTBL_STRU_NAME(class)
/* 类继承自父类的虚函数信息 */
#define INHERITED_V_METHOD(p_class) \
struct VTBL_STRU_NAME(p_class) parent_vtbl
/* 单个虚函数声明处 */
#define DEFINE_V_METHOD(ret_type, method) \
ret_type (* method )(void* this, ...)
/* 类中的虚函数声明结束宏 */
#define END_V_METHOD_DEFINE(class)
/* 根类的对象声明 */
#define ROOT_CLASS_DECLARE(class) \
struct VTBL_STRU_NAME(class) *vbtl;
/* 类中的声明结束宏 */
#define END_CLASS(class)
/* ======================================================================== */
/* 虚拟函数指针的使用 */
#define GET_V_METHOD_PTR(class, func) \
( VTBL_FUNC_PTR_NAME(class, func) )
/* 定义虚拟函数的类型 */
#define DEFINE_V_METHOD_TYPE(ret_type, class, method) \
typedef ret_type (* METHOD_TYPE(class, method) )
/* 定义虚拟函数的指针: 修改为奇数场景 */
#define DEFINE_V_METHOD_PTR(class, method) \
enum { VTBL_FUNC_PTR_NAME(class, method) = \
((((int )(&((struct VTBL_STRU_NAME(class) *)0)-> method )) \
/ sizeof(std_func_ptr))<<1) + 1 }; \
/* 定义继承的虚拟函数的指针 */
#define INHERITED_V_METHOD_PTR(class, parent, method) \
enum { VTBL_FUNC_PTR_NAME(class, method) = \
VTBL_FUNC_PTR_NAME(parent, method) }; \
/* 定义普通的虚拟函数的信息 */
#define DEFINE_V_METHOD_INFO(ret_type, class, method) \
DEFINE_V_METHOD_PTR(class, method); \
DEFINE_V_METHOD_TYPE(ret_type, class, method)
/* 定义继承的虚拟函数的信息 */
#define INHERITED_V_METHOD_INFO(ret_type, class, parent, method) \
INHERITED_V_METHOD_PTR(class, parent, method); \
DEFINE_V_METHOD_TYPE(ret_type, class, method)
/* 定义普通的成员函数的信息 */
#define DEFINE_C_METHOD_INFO(ret_type, class, method) \
extern ret_type METHOD(class, method)
/*
#define DEFINE_C_METHOD_INFO(ret_type, class, method) \
extern common_func_ptr __##class##_##method##_ptr__; \
typedef ret_type (* VTBL_FUNC_PTR_NAME(class, func) )
*/
/* 调用对象的虚拟函数 */
#define CALL_V_METHOD(object, method_ptr) \
(*(((*( common_func_ptr **) object ))[ ((unsigned int)method_ptr) >> 1 ]))
/* 调用对象的虚拟函数：支持参数严格校验 */
#define CALL_V_R_METHOD(object, class, method) \
(*(((*( METHOD_TYPE(class, method) **) object ))[ GET_V_METHOD_PTR(class,method) >> 1 ]))
/* 调用对象的普通成员函数 */
#define CALL_C_METHOD(object, class, method) \
METHOD(class, method)
/*
#define DECLARE_V_METHOD(ret_type, class, method) \
ret_type METHOD(class, method)
#define DECLARE_C_METHOD(ret_type, class, method) \
common_func_ptr __##class##_##method##_ptr__ = METHOD(class, method); \
ret_type METHOD(class, method)
#define CALL_C_METHOD(ret_type, class, method) \
*(VTBL_FUNC_PTR_NAME(class, method)__##class##_##method##_ptr__)
*/
/* ======================================================================== */
/* 实现类，主要是绑定类的虚拟函数指针 */
#define BEGIN_DECLARE_CLASS_VTABLE(class) \
static std_func_ptr VTBL_ENTITY_NAME(class) [ \
sizeof(struct VTBL_STRU_NAME(class) )/sizeof(std_func_ptr)] = {0}; \
static char VTBL_ENTITY_IS_INIT_FLAG(class) = 0; \
static int VTBL_ENTITY_INIT_METHOD(class) (std_func_ptr *vtbl) \
{ \
if (0 != VTBL_ENTITY_IS_INIT_FLAG(class) ) return 1; \
if (0 == vtbl) return 0; \
do
/* 继承父类的VTABLE */
#define INHERITED_VTABLE_INIT(parent) \
if (0 == VTBL_ENTITY_INIT_METHOD_PTR(parent) (vtbl)) return 0
/* 继承的虚函数表项初始化 */
#define INHERITED_VTABLE_METHOD_INIT(class, parent, method) \
vtbl[((int )(&((struct VTBL_STRU_NAME(parent) * )0)-> method )) \
/ sizeof(std_func_ptr)] \
= (std_func_ptr) METHOD(class, method)
/* 自身的虚函数表项初始化 */
#define SELF_VTABLE_METHOD_INIT(class, method) \
INHERITED_VTABLE_METHOD_INIT(class, class, method)
/* 实现类的结束宏 */
#define END_DECLARE_CLASS_VTABLE(class) \
while(0); \
VTBL_ENTITY_IS_INIT_FLAG(class) = 1; \
return 1; \
} \
class_vtable_init VTBL_ENTITY_INIT_STRU_VAR(class) = \
{ VTBL_ENTITY_INIT_METHOD(class), VTBL_ENTITY_NAME(class)};
/* ======================================================================== */
/* ======================================================================== */
/* 类的构造函数，主要提供两个接口：
一个是create，以支持new，
一个是constructor，就是构造并初始化的函数 */
#define BEGIN_CONSTRUCTOR(class, parent) \
extern int METHOD(class, constructor) (class * this); \
class* METHOD(class, create) (void) \
{ \
return common_create_object(sizeof( class ), \
(std_func_ptr) METHOD(class, constructor)); \
} \
\
int METHOD(class, constructor) (class * this) \
{ \
VTBL_ENTITY_INIT_METHOD(class) ( VTBL_ENTITY_NAME(class) ); \
if (0 != METHOD(parent, constructor) (( parent *)(this))) \
return 1; \
*(struct VTBL_STRU_NAME(class) **)this = \
(struct VTBL_STRU_NAME(class) *) VTBL_ENTITY_NAME(class) ; \
do \
/* 类构造函数的结束宏 */
#define END_CONSTRUCTOR(class, parent) \
while(0); \
return 0; \
}
/* 根类的父类构造函数为0 */
#define void_constructor(this) (0)
/* ======================================================================== */
/* ======================================================================== */
/* 类的析构函数，主要提供两个接口：
一个是destory，以支持delete，
一个是destructor，就是析构函数 */
#define BEGIN_DESTRUCTOR(class, parent) \
extern int METHOD(class, destructor) (class * this); \
void METHOD(class, destory) ( class * this) \
{ \
common_destory_object( this , \
(std_func_ptr) METHOD(class, destructor) ); \
} \
\
int METHOD(class, destructor) (class * this) \
{ \
do \
/* 类析构函数的结束宏 */
#define END_DESTRUCTOR(class, parent) \
while(0); \
if (0 != METHOD(parent, destructor) (( parent *)(this))) \
return 1; \
return 0; \
}
/* 根类的父类析构函数为0 */
#define void_destructor(this) (0)
/* ======================================================================== */
typedef int (*std_func_ptr)(void*);
typedef int (*common_func_ptr)(void*, ...);
typedef struct
{
int (*vtable_init_method)(std_func_ptr*);
std_func_ptr vtable_array;
}class_vtable_init;
void* common_create_object(unsigned int size, std_func_ptr pCtor);
void common_destory_object(void* this, std_func_ptr pDtor);
void common_destory_object_non_virtual(void* this, std_func_ptr pDtor);
#ifdef __cplusplus
};
#endif /* end of __cplusplus */
#endif
#include "ooc.hoo"
#include <stdio.h>
#include <stdlib.h>
void* common_create_object(unsigned int size, std_func_ptr pCtor)
{
/* 分配对象 */
void* object = malloc(size);
/* 如果分配失败，返回0 */
if (0 == object)
return 0;
/* 调用构造函数 */
if (0 != (*pCtor)(object))
{
/* 构造函数执行失败，释放对象 */
free(object);
return 0;
}
/* 成功，返回对象 */
return object;
}
void common_destory_object(void* this, std_func_ptr pDtor)
{
/* 如果对象为空 */
if (0 == this) return;
/* 如果存在虚函数表指针 */
if (0 != *(void**)this)
{
/* 调用虚函数表中的第一个函数指针，默认此函数为析构函数 */
if (0 != (*((*(std_func_ptr**)this)[0]))((void*)this))
return;
}
else
{
/* 不为空，则调用传入的析构函数指针 */
if (0 != (*pDtor)(this))
return;
}
/* 最后释放对象 */
free(this);
}
void common_destory_object_non_virtual(void* this, std_func_ptr pDtor)
{
if (0 == this) return;
if (0 != (*pDtor)(this))
return;
/* free */
free(this);
}
#ifndef __BASE_OBJECT_STRUCT__
#define __BASE_OBJECT_STRUCT__
#include <glib.h>
#include <glib-object.h>
#include "ooc.hoo"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __GNUC__
#define SIGNAL_CALLBACK __cdcel
#else
#define SIGNAL_CALLBACK __attribute__((cdecl))
#endif
BEGIN_CLASS(BaseObject)
{
/* 类自身的数据 */
ROOT_CLASS_DECLARE(BaseObject)
/* 虚拟函数表的定义处 */
BEGIN_V_METHOD_DEFINE(BaseObject)
{
/* 自身的虚函数 */
DEFINE_V_METHOD(int, destructor);
/* 自身的虚函数 */
DEFINE_V_METHOD(gulong, setupObject);
}
END_V_METHOD_DEFINE(BaseObject);
/* 对象的数据 */
GObject* x_pObject;
GSList* x_pObjectList;
}
END_CLASS(BaseObject);
typedef gulong (*CommonCallback)(BaseObject* this, GObject*instance, ...);
typedef struct ObjectCallbackInfo
{
BaseObject* x_pThis;
CommonCallback x_pCallback;
GObject* x_pWidget;
} ObjectCallbackInfo;
DEFINE_V_METHOD_INFO(int , BaseObject, destructor) (BaseObject* this);
DEFINE_V_METHOD_INFO(gulong , BaseObject, setupObject) (BaseObject* this);
DEFINE_C_METHOD_INFO(gulong , BaseObject, ConnectSignal) (BaseObject* this, gpointer instance, const gchar *detailed_signal, CommonCallback c_handler);
DEFINE_C_METHOD_INFO(gulong , BaseObject, SignalProc) (const ObjectCallbackInfo* lpObject, ...);
#ifdef __cplusplus
};
#endif /* end of __cplusplus */
#endif
#include "BaseObject.hoo"
gulong METHOD(BaseObject, SignalProc)(const ObjectCallbackInfo* lpObject, ...)
{
va_list pArgList;
gulong ulRetcode;
struct reserve_arg { gulong ulReserver[20];} *pstTemp;
/* 收到信号时，先判断指针 */
if ( (NULL == lpObject) || (NULL == lpObject->x_pCallback ) || (NULL == lpObject->x_pWidget))
{
return 0;
}
/* 取出this指针及成员函数指针 */
va_start(pArgList, lpObject);
pstTemp = (struct reserve_arg*)pArgList;
/* 调用成员函数 */
if ((((unsigned int)lpObject->x_pCallback) & 0x1) == 0x1)
{
printf("enter virtual method branch!\n");
ulRetcode = CALL_V_METHOD ((lpObject->x_pThis), (lpObject->x_pCallback)) (lpObject->x_pThis, lpObject->x_pWidget, *pstTemp);
}
else
{
ulRetcode = (*(lpObject->x_pCallback))(lpObject->x_pThis, lpObject->x_pWidget, *pstTemp);
}
va_end(pArgList);
return ulRetcode;
}
gulong METHOD(BaseObject, ConnectSignal)(BaseObject* this, gpointer instance,
const gchar *detailed_signal,
CommonCallback c_handler)
{
/* 分配存放回调指针的空间 */
ObjectCallbackInfo* lpObject = (ObjectCallbackInfo*)g_malloc(sizeof(ObjectCallbackInfo));
if (NULL == lpObject)
{
return 0;
}
lpObject->x_pThis = this;
lpObject->x_pCallback = c_handler;
lpObject->x_pWidget = (GObject*)instance;
/* 将信息保存在slist中 */
this->x_pObjectList = g_slist_append(this->x_pObjectList, lpObject);
/* 注册信号回调 */
return g_signal_connect_swapped(instance, detailed_signal,
(GCallback)&( METHOD(BaseObject, SignalProc) ),
(gpointer)lpObject);
}
BEGIN_DECLARE_CLASS_VTABLE(BaseObject)
{
SELF_VTABLE_METHOD_INIT(BaseObject, destructor);
}
END_DECLARE_CLASS_VTABLE(BaseObject)
BEGIN_CONSTRUCTOR(BaseObject, void)
{
this->x_pObject = NULL;
this->x_pObjectList = NULL;
}
END_CONSTRUCTOR(BaseObject, void)
BEGIN_DESTRUCTOR(BaseObject, void)
{
/* 释放所有分配的ObjectToMemFunc空间 */
gpointer lpObj;
GSList* lpTempList = this->x_pObjectList;
while (NULL != lpTempList)
{
/* 如果非空 */
lpObj = g_slist_nth_data(lpTempList, 0);
if (NULL != lpObj)
{
g_free(lpObj);
}
lpTempList = g_slist_next(lpTempList);
}
/* 删除列表 */
if (NULL != this->x_pObjectList)
{
g_slist_free(this->x_pObjectList);
}
}
END_DESTRUCTOR(BaseObject, void)
#ifndef __UI_TEST_WIN__
#define __UI_TEST_WIN__
#include "BaseObject.hoo"
#include <gtk/gtk.h>
/* 测试的第一个类 */
BEGIN_CLASS(TestDialog)
{
/* 继承自NullClass */
INHERITED_PARENT(BaseObject);
/* 虚拟函数表的定义处 */
BEGIN_V_METHOD_DEFINE(TestDialog)
{
/* 继承自NullClass */
INHERITED_V_METHOD(BaseObject);
/* 自身的虚函数 */
DEFINE_V_METHOD(SIGNAL_CALLBACK gulong, OnOk) ;
DEFINE_V_METHOD(SIGNAL_CALLBACK gulong, OnChange) ;
}
END_V_METHOD_DEFINE(TestDialog);
/* 类自身的数据 */
/* GtkWidget *calendar1; */
GtkWidget *notebook1;
GtkWidget *empty_notebook_page;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
}
END_CLASS(TestDialog);
INHERITED_V_METHOD_INFO(int , TestDialog, BaseObject, destructor) (TestDialog* this);
INHERITED_V_METHOD_INFO(int, TestDialog, BaseObject, setupObject) (TestDialog* this);
DEFINE_V_METHOD_INFO(SIGNAL_CALLBACK gulong, TestDialog, OnOk) (TestDialog* this, GtkWidget *notebook1);
DEFINE_V_METHOD_INFO(SIGNAL_CALLBACK gulong, TestDialog, OnChange) (TestDialog* this, GtkWidget *notebook1, GtkNotebookPage *page, guint num);
#endif
#include "ui_testwin.hoo"
gulong METHOD(TestDialog, OnOk)(TestDialog* this, GtkWidget *notebook1)
{
printf("this : %08x\n", this);
printf("notebook : %08x\n", notebook1);
fflush(stdout);
gtk_main_quit();
return 0;
}
gulong METHOD(TestDialog, OnChange)(TestDialog* this, GtkWidget *notebook1, GtkNotebookPage *page, guint num)
{
printf("this : %08x\n", this);
printf("notebook : %08x\n", notebook1);
printf("page : %08x\n", page);
printf("Current Page: %d(%08x)\n", num, num);
return 0;
}
gulong METHOD(TestDialog, setupObject)(TestDialog* this)
{
GtkWidget* window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window1), "window1");
METHOD(BaseObject, ConnectSignal) (this, G_OBJECT (window1), "destroy", (CommonCallback)( GET_V_METHOD_PTR(TestDialog, OnOk )));
this->notebook1 = gtk_notebook_new ();
gtk_widget_show (this->notebook1);
gtk_container_add (GTK_CONTAINER (window1), this->notebook1);
this->empty_notebook_page = gtk_vbox_new (FALSE, 0);
gtk_widget_show (this->empty_notebook_page);
gtk_container_add (GTK_CONTAINER (this->notebook1), this->empty_notebook_page);
this->label1 = gtk_label_new (("label1"));
gtk_widget_show (this->label1);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (this->notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (this->notebook1), 0), this->label1);
this->empty_notebook_page = gtk_vbox_new (FALSE, 0);
gtk_widget_show (this->empty_notebook_page);
gtk_container_add (GTK_CONTAINER (this->notebook1), this->empty_notebook_page);
this->label2 = gtk_label_new (("label2"));
gtk_widget_show (this->label2);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (this->notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (this->notebook1), 1), this->label2);
this->empty_notebook_page = gtk_vbox_new (FALSE, 0);
gtk_widget_show (this->empty_notebook_page);
gtk_container_add (GTK_CONTAINER (this->notebook1), this->empty_notebook_page);
this->label3 = gtk_label_new (("label3"));
gtk_widget_show (this->label3);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (this->notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (this->notebook1), 2), this->label3);
METHOD(BaseObject, ConnectSignal) (this, G_OBJECT (this->notebook1), "switch-page", (CommonCallback)(GET_V_METHOD_PTR(TestDialog,OnChange)));
/* Store pointers to all widgets, for use by lookup_widget(). */
//GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1");
//GLADE_HOOKUP_OBJECT (window1, calendar1, "calendar1");
gtk_widget_show(window1);
/* 存放对象的基类指针 */
this->parent.x_pObject = (GObject*)window1;
return 0;
}
BEGIN_DECLARE_CLASS_VTABLE(TestDialog)
{
INHERITED_VTABLE_INIT(BaseObject);
INHERITED_VTABLE_METHOD_INIT(TestDialog, BaseObject, destructor);
INHERITED_VTABLE_METHOD_INIT(TestDialog, BaseObject, setupObject);
SELF_VTABLE_METHOD_INIT(TestDialog, OnOk);
SELF_VTABLE_METHOD_INIT(TestDialog, OnChange);
}
END_DECLARE_CLASS_VTABLE(TestDialog)
BEGIN_CONSTRUCTOR(TestDialog, BaseObject)
{
}
END_CONSTRUCTOR(TestDialog, BaseObject)
BEGIN_DESTRUCTOR(TestDialog, BaseObject)
{
}
END_DESTRUCTOR(TestClass, BaseObject)
int main (int argc, char *argv[])
{
TestDialog* lpDialog = NULL;
gtk_init(&argc, &argv);
lpDialog = new(TestDialog);
CALL_V_R_METHOD(lpDialog, TestDialog, setupObject)(lpDialog);
gtk_main ();
delete(TestDialog, lpDialog);
return 0;
}
