自学教程：C++ DECL_PRIV函数代码示例

FtkSource* ftk_source_dfb_create(IDirectFB* dfb){	FtkSource* thiz = FTK_ZALLOC(sizeof(FtkSource)+sizeof(PrivInfo));	if(thiz != NULL)	{		int fd = 0;		DECL_PRIV(thiz, priv);		IDirectFBEventBuffer* event_buffer = NULL;		thiz->get_fd   =  ftk_source_dfb_get_fd;		thiz->check    = ftk_source_dfb_check;		thiz->dispatch = ftk_source_dfb_dispatch;		thiz->destroy  = ftk_source_dfb_destroy;		dfb->CreateInputEventBuffer( dfb, DICAPS_ALL, DFB_FALSE, &event_buffer );		if(event_buffer != NULL)		{			event_buffer->CreateFileDescriptor(event_buffer, &fd);		}		thiz->ref = 1;		priv->fd = fd;		priv->event_buffer = event_buffer;	}	return thiz;}

static int ftk_source_primary_get_fd(FtkSource* thiz){	DECL_PRIV(thiz, priv);	return_val_if_fail(priv != NULL, -1);	return ftk_pipe_get_read_handle(priv->pipe);}

FtkSource* ftk_source_ps2mouse_create(const char* filename, FtkOnEvent on_event, void* user_data, int max_x, int max_y){	FtkSource* thiz = (FtkSource*)FTK_ZALLOC(sizeof(FtkSource) + sizeof(PrivInfo));	if(thiz != NULL)	{		DECL_PRIV(thiz, priv);		thiz->get_fd   = ftk_source_ps2mouse_get_fd;		thiz->check    = ftk_source_ps2mouse_check;		thiz->dispatch = ftk_source_ps2mouse_dispatch;		thiz->destroy  = ftk_source_ps2mouse_destroy;		thiz->ref = 1;		priv->fd = open(filename, O_RDONLY);		ftk_strncpy(priv->filename, filename, sizeof(priv->filename));		open_device(priv, max_x, max_y);		if(priv->fd < 0)		{			FTK_ZFREE(thiz, sizeof(thiz) + sizeof(PrivInfo));			return NULL;		}		priv->on_event = on_event;		priv->user_data = user_data;		priv->is_first_move = true;		ftk_logd("%s: %d=%s priv->user_data=%p/n", __func__, priv->fd, filename, priv->user_data);	}	return thiz;}

static Ret ftk_canvas_default_draw_bitmap_normal(FtkCanvas* thiz, FtkBitmap* bitmap, FtkRect* s, FtkRect* d){    int i = 0;    int j = 0;    int k = 0;    int x = s->x;    int y = s->y;    int w = s->width;    int h = s->height;    int xoffset = d->x;    int yoffset = d->y;    FtkColor* src = NULL;    FtkColor* dst = NULL;    FtkColor* psrc = NULL;    FtkColor* pdst = NULL;    unsigned char alpha = 0;    DECL_PRIV(thiz, priv);    int width  = priv->w;    int height = priv->h;    int bitmap_width   = ftk_bitmap_width(bitmap);    int bitmap_height  = ftk_bitmap_height(bitmap);    return_val_if_fail(thiz != NULL && bitmap != NULL, RET_FAIL);    return_val_if_fail(x < bitmap_width, RET_FAIL);    return_val_if_fail(y < bitmap_height, RET_FAIL);    return_val_if_fail(xoffset < width, RET_FAIL);    return_val_if_fail(yoffset < height, RET_FAIL);    src = ftk_bitmap_lock(bitmap);    dst = priv->bits;    w = (x + w) < bitmap_width  ? w : bitmap_width - x;    w = (xoffset + w) < width  ? w : width  - xoffset;    h = (y + h) < bitmap_height ? h : bitmap_height - y;    h = (yoffset + h) < height ? h : height - yoffset;    w += x;    h += y;    src += y * bitmap_width;    dst += yoffset * width;    if(thiz->gc.mask & FTK_GC_ALPHA)    {        for(i = y; i < h; i++)        {            for(j = x, k = xoffset; j < w; j++, k++)            {                pdst = dst+k;                psrc = src+j;                alpha = (psrc->a * thiz->gc.alpha) >> 8;                PUT_PIXEL(pdst, psrc, alpha);            }            src += bitmap_width;            dst += width;        }    }    else    {        for(i = y; i < h; i++)

static Ret  ftk_wnd_manager_default_map_panels(FtkWndManager* thiz, int map){	int i = 0;	Ret ret = RET_IGNORED;	FtkEvent event;	FtkWidget* win = NULL;	DECL_PRIV(thiz, priv);	return_val_if_fail(thiz != NULL && priv->top > 0, RET_FAIL);		for(i = 0; i < priv->top; i++)	{		win = priv->windows[i];		if(ftk_widget_type(win) == FTK_STATUS_PANEL && ftk_widget_is_visible(win))		{			if(!(map && ftk_window_is_mapped(win)))			{				ftk_event_init(&event, map ? FTK_EVT_MAP : FTK_EVT_UNMAP);				event.widget = win;				ftk_wnd_manager_dispatch_event(thiz, &event);				ret = RET_OK;			}			ftk_widget_invalidate(win);		}	}	return ret;}

static Ret ftk_canvas_default_draw_hline(FtkCanvas* thiz, int x, int y, int w){    int i = 0;    int width = 0;    int height = 0;    FtkColor* bits = NULL;    unsigned char alpha = 0;    FtkColor* pdst = NULL;    FtkColor* color = NULL;    DECL_PRIV(thiz, priv);    width  = priv->w;    height = priv->h;    bits   = priv->bits;    return_val_if_fail(bits != NULL && x < width, RET_FAIL);    return_val_if_fail(y < height, RET_FAIL);    alpha = thiz->gc.mask & FTK_GC_ALPHA ? thiz->gc.alpha :  thiz->gc.fg.a;    x = x < 0 ? 0 : x;    y = y < 0 ? 0 : y;    w = (x + w) < width ? w : width - x;    color = &(thiz->gc.fg);    pdst = bits + y * width + x;    for(i = w; i > 0; i--, pdst++)    {        PUT_PIXEL(pdst, color, alpha);    }    return RET_OK;}

static Ret ftk_canvas_default_draw_round_rect(FtkCanvas* thiz, int x, int y, int w, int h, int fill){    int width  = 0;    int height = 0;    DECL_PRIV(thiz, priv);    width  = priv->w;    height = priv->h;    return_val_if_fail(x < width && y < height, RET_FAIL);    return_val_if_fail(w > 8 && h > 8, RET_FAIL);    ftk_canvas_default_draw_hline(thiz, x + 2, y, w-4);    ftk_canvas_default_draw_hline(thiz, x + 1, y + 1, w-2);    ftk_canvas_default_draw_vline(thiz, x, y + 2, h - 4);    ftk_canvas_default_draw_vline(thiz, x + 1, y + 1, h - 2);    ftk_canvas_default_draw_vline(thiz, x+w-1, y + 2, h - 4);    ftk_canvas_default_draw_vline(thiz, x + w -2, y + 1, h - 2);    ftk_canvas_default_draw_hline(thiz, x + 1, y + h - 1, w-2);    ftk_canvas_default_draw_hline(thiz, x + 2, y + h - 2, w-4);    if(fill)    {        ftk_canvas_default_draw_rect_impl(thiz, x + 2, y + 2, w - 4, h - 4, fill);    }    return RET_OK;}

static int ftk_display_mem_width(FtkDisplay* thiz){	DECL_PRIV(thiz, priv);	return_val_if_fail(priv != NULL, 0);	return priv->width;}

static int ftk_display_mem_height(FtkDisplay* thiz){	DECL_PRIV(thiz, priv);	return_val_if_fail(priv != NULL, 0);	return priv->height;}

Ret ftk_display_mem_update_directly(FtkDisplay* thiz, FtkPixelFormat format,	void* bits, size_t width, size_t height, size_t xoffset, size_t yoffset){	size_t w = 0;	size_t h = 0;	char* src = NULL;	char* dst = NULL;	DECL_PRIV(thiz, priv);	return_val_if_fail(bits != NULL, RET_FAIL);	return_val_if_fail(ftk_display_mem_is_active(thiz), RET_FAIL);	return_val_if_fail(xoffset < priv->width && yoffset < priv->height, RET_FAIL);	w = (xoffset + width) < priv->width ? width : priv->width - xoffset;	h = (yoffset + height) < priv->height ? height : priv->height - yoffset;	if(format == priv->format)	{		src = (char*)bits;		dst = (char*)priv->bits + priv->width * priv->bpp + xoffset;		for(; h; h--)		{			memcpy(dst, src, priv->bpp * w);			dst += priv->width * priv->bpp;			src += width * priv->bpp;		}	}	else	{		/*TODO*/		assert(!"not supprted yet");	}	return RET_OK;}

static Ret ftk_display_mem_update(FtkDisplay* thiz, FtkBitmap* bitmap, FtkRect* rect, int xoffset, int yoffset){	Ret ret = RET_OK;	DECL_PRIV(thiz, priv);	int display_width  = priv->width;	int display_height = priv->height;	return_val_if_fail(priv != NULL, RET_FAIL);	ftk_logd("%s: ox=%d oy=%d (%d %d %d %d)/n", __func__, xoffset, yoffset, 		rect->x, rect->y, rect->width, rect->height);	ret = priv->copy_to_data(bitmap, rect, 		priv->bits, xoffset, yoffset, display_width, display_height); 	if(priv->sync != NULL && ret == RET_OK)	{		FtkRect r;		r.x = xoffset;		r.y = yoffset;		r.width = rect->width;		r.height = rect->height;		priv->sync(priv->sync_ctx, &r);	}	return ret;}

static FtkBitmap* ftk_app_demo_get_icon(FtkApp* thiz){    DECL_PRIV(thiz, priv);    return_val_if_fail(priv != NULL, NULL);    return priv->icon;}

static const char* ftk_app_demo_get_name(FtkApp* thiz){    DECL_PRIV(thiz, priv);    return_val_if_fail(priv != NULL, NULL);    return priv->name;}

FtkInputMethod* ftk_input_method_hw_create(void){	FtkInputMethod* thiz = FTK_ZALLOC(sizeof(FtkInputMethod) + sizeof(PrivInfo));	if(thiz != NULL)	{		FtkColor c = {0};		DECL_PRIV(thiz, priv);		thiz->ref  = 1;		thiz->name = _("Hand Write");			thiz->set_type     = ftk_input_method_hw_set_type;		thiz->focus_in     = ftk_input_method_hw_focus_in;		thiz->focus_out    = ftk_input_method_hw_focus_out;		thiz->handle_event = ftk_input_method_hw_handle_event;		thiz->destroy      = ftk_input_method_hw_destroy;		c.r = 0xff;		c.b = 0xff;		priv->painter = ftk_stroke_painter_create();		priv->engine = ftk_hand_write_engine_create(on_handwrite_result, thiz);		ftk_input_method_hw_set_rect(thiz, NULL);		ftk_input_method_hw_set_pen_width(thiz, 3);		ftk_input_method_hw_set_pen_color(thiz, c);		ftk_input_method_hw_set_click_timeout(thiz, 300);		ftk_input_method_hw_set_commit_timeout(thiz, 1500);	}	return thiz;}

FtkSource* ftk_source_psp_create(FtkDisplay* display, FtkOnEvent on_event, void* ctx){	FtkSource* thiz = NULL;		return_val_if_fail(display != NULL && on_event != NULL, NULL);	thiz = (FtkSource*)FTK_ZALLOC(sizeof(FtkSource) + sizeof(PrivInfo));	if(thiz != NULL)	{		DECL_PRIV(thiz, priv);		thiz->get_fd   = ftk_source_psp_get_fd;		thiz->check	   = ftk_source_psp_check;		thiz->dispatch = ftk_source_psp_dispatch;		thiz->destroy  = ftk_source_psp_destroy;		thiz->ref = 1;		priv->ctx = ctx;		priv->on_event = on_event;		priv->display = display;		priv->psp_keypress = 0;	}	return thiz;}

FtkSource* ftk_source_x11_create(FtkDisplay* display, FtkOnEvent on_event, void* ctx){	FtkSource* thiz = NULL;		return_val_if_fail(display != NULL && on_event != NULL, NULL);	thiz = (FtkSource*)FTK_ZALLOC(sizeof(FtkSource) + sizeof(PrivInfo));	if(thiz != NULL)	{		DECL_PRIV(thiz, priv);		thiz->get_fd   = ftk_source_x11_get_fd;		thiz->check	   = ftk_source_x11_check;		thiz->dispatch = ftk_source_x11_dispatch;		thiz->destroy  = ftk_source_x11_destroy;		thiz->ref = 1;		priv->ctx = ctx;		priv->on_event = on_event;		priv->display = display;		priv->fd  = ConnectionNumber(ftk_display_x11_get_xdisplay(display));		priv->win = (Window)ftk_display_x11_get_xwindow(display);		XSetErrorHandler(on_x11_error);	}	return thiz;}

static Ret ftk_canvas_default_draw_vline(FtkCanvas* thiz, int x, int y, int h){    int i = 0;    int width = 0;    int height = 0;    FtkColor* bits = NULL;    unsigned char alpha = 0;    FtkColor* pdst = NULL;    FtkColor* color = NULL;    DECL_PRIV(thiz, priv);    width  = priv->w;    height = priv->h;    bits   = priv->bits;    return_val_if_fail(bits != NULL && y < height, RET_FAIL);    alpha = thiz->gc.mask & FTK_GC_ALPHA ? thiz->gc.alpha :  thiz->gc.fg.a;    x = x < 0 ? 0 : x;    y = y < 0 ? 0 : y;    h = (y + h) < height ? h : (height - y);    pdst = bits + width * y + x;    color = &(thiz->gc.fg);    for(i = h; i > 0; i--, pdst+=width)    {        PUT_PIXEL(pdst, color, alpha);    }    return RET_OK;}

FtkDisplay* ftk_display_android_create(void){	FtkDisplay* thiz = NULL;	thiz = (FtkDisplay*)FTK_ZALLOC(sizeof(FtkDisplay) + sizeof(PrivInfo));	if(thiz != NULL)	{		FtkColor bg;		DECL_PRIV(thiz, priv);		thiz->update   = ftk_display_android_update;		thiz->width    = ftk_display_android_width;		thiz->height   = ftk_display_android_height;		thiz->snap     = ftk_display_android_snap;		thiz->destroy  = ftk_display_android_destroy;		bg.a = 0xff;		bg.r = 0xff;		bg.g = 0xff;		bg.b = 0xff;		priv->bitmap = ftk_bitmap_create(screen_width, screen_height, bg);		ftk_wnd_manager_add_global_listener(ftk_default_wnd_manager(),			(FtkListener)ftk_display_android_handle_event, thiz);		Android_InitEGL();	}	return thiz;}

static Ret ftk_canvas_default_draw_rect_impl(FtkCanvas* thiz, int x, int y, int w, int h, int fill){    int i = 0;    int width  = 0;    int height = 0;    DECL_PRIV(thiz, priv);    width  = priv->w;    height = priv->h;    return_val_if_fail(x < width && y < height, RET_FAIL);    if(fill)    {        for(i = 0; i < h; i++)        {            if((y + i) < height)            {                ftk_canvas_default_draw_hline(thiz, x, (y+i), w);            }        }    }    else    {        ftk_canvas_default_draw_hline(thiz, x,   y, w);        ftk_canvas_default_draw_hline(thiz, x,   y+h-1, w);        ftk_canvas_default_draw_vline(thiz, x,   y, h);        ftk_canvas_default_draw_vline(thiz, x+w-1, y, h);    }    return RET_OK;}

static Ret   ftk_animation_alpha_step(FtkAnimation* thiz){	FtkRect r = {0};	float percent = 0;	DECL_PRIV(thiz, priv);	r = priv->back_win_rect;	if(r.width > 0 && r.height > 0)	{		ftk_canvas_draw_bitmap(ftk_shared_canvas(), priv->back_win, &r, &r, 0xff);	}	percent = priv->start + (priv->end - priv->start) * ftk_animation_get_percent(thiz);	r = priv->front_win_rect;	if(r.width > 0 && r.height > 0)	{		int alpha = (int)(0xff * percent) & 0xff;		ftk_canvas_draw_bitmap(ftk_shared_canvas(), priv->front_win, &r, &r, alpha);	}	ftk_canvas_show(ftk_shared_canvas(), ftk_default_display(), &r, r.x, r.y);	return RET_OK;}

static Ret ftk_canvas_default_draw_rect(FtkCanvas* thiz, int x, int y, int w, int h,                                        int round, int fill){    Ret ret = RET_FAIL;    FtkRect rect = {0};    DECL_PRIV(thiz, priv);    rect.x = x;    rect.y = y;    rect.width = w;    rect.height = h;    if(ftk_rect_and(&rect, &priv->clip->rect, &rect) != RET_OK)    {//		ftk_logd("%s: skip./n", __func__);        return RET_OK;    }    x = rect.x;    y = rect.y;    w = rect.width;    h = rect.height;    if(round)    {        ret = ftk_canvas_default_draw_round_rect(thiz, x, y, w, h, fill);    }    else    {        ret = ftk_canvas_default_draw_rect_impl(thiz, x, y, w, h, fill);    }    return ret;}

static Ret   ftk_animation_alpha_reset(FtkAnimation* thiz, FtkBitmap* old_win, FtkBitmap* new_win,	FtkRect* old_win_rect, FtkRect* new_win_rect){	DECL_PRIV(thiz, priv);	const char* src = ftk_animation_get_param(thiz, "src");	return_val_if_fail(src != NULL, RET_FAIL);	priv->start = ftk_animation_get_param_float(thiz, "from", 1.0);	priv->end = ftk_animation_get_param_float(thiz, "to", 1.0);	if(strstr(src, "new_window") != NULL)	{		priv->back_win = old_win;		priv->back_win_rect = *old_win_rect;				priv->front_win = new_win;		priv->front_win_rect = *new_win_rect;	}	else	{		priv->back_win = new_win;		priv->back_win_rect = *new_win_rect;				priv->front_win = old_win;		priv->front_win_rect = *old_win_rect;	}	ftk_logd("%s: src=%s start=%f end=%f old(%d %d %d %d) new(%d %d %d %d)",		__func__, src, priv->start, priv->end, 		old_win_rect->x, old_win_rect->y, old_win_rect->width, old_win_rect->height,		new_win_rect->x, new_win_rect->y, new_win_rect->width, new_win_rect->height);	return RET_OK;}

static FtkWidget* ftk_wnd_manager_find_target(FtkWndManager* thiz, int x, int y){	int i = 0;	int top = 0;	int left = 0;	int w = 0;	int h = 0;	DECL_PRIV(thiz, priv);	return_val_if_fail(thiz != NULL && priv->top > 0, NULL);		i = priv->top;	for(; i > 0; i--)	{		FtkWidget* win = priv->windows[i-1];		if(!ftk_widget_is_visible(win) || !ftk_window_is_mapped(win))		{			continue;		}			top = ftk_widget_top_abs(win);		left = ftk_widget_left_abs(win);		w = ftk_widget_width(win);		h = ftk_widget_height(win);		if(x >= left && y >= top && x < (left  + w)	&& y < (top + h))		{			return win;		}	}	return NULL;}

static void ftk_animation_trigger_default_destroy(FtkAnimationTrigger* thiz){	if(thiz != NULL)	{		int i = 0;		DECL_PRIV(thiz, priv);		for(i = 0; i < priv->type_and_animations_nr; i++)		{			size_t j = 0;			for(j = 0; j < FTK_MAX_ANIMATION_NR; j++)			{				if(priv->type_and_animations[i].animations[j] != NULL)				{					ftk_animation_destroy(priv->type_and_animations[i].animations[j]);				}			}		}		ftk_canvas_destroy(priv->old_window);		ftk_canvas_destroy(priv->new_window);		FTK_FREE(thiz);	}	return;}

FtkWndManager* ftk_wnd_manager_default_create(FtkMainLoop* main_loop){	FtkWndManager* thiz = NULL;	return_val_if_fail(main_loop != NULL, NULL);	if((thiz = (FtkWndManager*)FTK_ZALLOC(sizeof(FtkWndManager) + sizeof(PrivInfo))) != NULL)	{		DECL_PRIV(thiz, priv);		priv->main_loop = main_loop;		priv->long_press_timer = ftk_source_timer_create(1500, (FtkTimer)ftk_wnd_manager_default_long_press, thiz);		ftk_set_primary_source(ftk_source_primary_create((FtkOnEvent)ftk_wnd_manager_default_dispatch_event, thiz));		ftk_sources_manager_add(ftk_default_sources_manager(), ftk_primary_source());		thiz->grab   = ftk_wnd_manager_default_grab;		thiz->ungrab = ftk_wnd_manager_default_ungrab;		thiz->add    = ftk_wnd_manager_default_add;		thiz->remove = ftk_wnd_manager_default_remove;		thiz->restack= ftk_wnd_manager_default_restack;		thiz->update         = ftk_wnd_manager_default_update;		thiz->get_work_area  = ftk_wnd_manager_default_get_work_area;		thiz->queue_event    = ftk_wnd_manager_default_queue_event;		thiz->dispatch_event         = ftk_wnd_manager_default_dispatch_event;		thiz->add_global_listener    = ftk_wnd_manager_default_add_global_listener;		thiz->remove_global_listener = ftk_wnd_manager_default_remove_global_listener;		thiz->destroy                = ftk_wnd_manager_default_destroy;#ifndef FTK_SUPPORT_C99	key_tanslate_table_init();#endif	}	return thiz;}

static Ret ftk_animation_trigger_default_ensure_canvas(FtkAnimationTrigger* thiz){	int w = 0;	int h = 0;	FtkColor bg = {0};	DECL_PRIV(thiz, priv);	if(priv->old_window && priv->new_window)	{		return RET_OK;	}	bg.a = 0xff;	w = ftk_display_width(ftk_default_display());	h = ftk_display_height(ftk_default_display());	if(priv->old_window == NULL)	{		priv->old_window = ftk_canvas_create(w, h, &bg);	}		if(priv->new_window == NULL)	{		priv->new_window = ftk_canvas_create(w, h, &bg);	}	return priv->old_window && priv->new_window ? RET_OK : RET_FAIL;}

static Ret ftk_source_primary_dispatch(FtkSource* thiz){	FtkEvent event = {0};	DECL_PRIV(thiz, priv);	int ret = ftk_pipe_read(priv->pipe, &event, sizeof(FtkEvent));	return_val_if_fail(ret == sizeof(FtkEvent), RET_REMOVE);	switch(event.type)	{		case FTK_EVT_NOP:		{			break;		}		case FTK_EVT_ADD_SOURCE:		{			ftk_sources_manager_add(ftk_default_sources_manager(), event.u.extra);			break;		}		case FTK_EVT_REMOVE_SOURCE:		{			ftk_sources_manager_remove(ftk_default_sources_manager(), event.u.extra);			break;		}		default:		{			if(priv->on_event != NULL)			{				priv->on_event(priv->user_data, &event);			}		}	}	return RET_OK;}

static Ret ftk_font_freetype_lookup (FtkFont* thiz, unsigned short code, FtkGlyph* glyph){	int index = 0;	FT_Error err = 0;	DECL_PRIV(thiz, priv);	return_val_if_fail(thiz != NULL && glyph != NULL, RET_FAIL);	index = FT_Get_Char_Index(priv->face, code);	err = FT_Load_Glyph(priv->face, index, FT_LOAD_DEFAULT|FT_LOAD_RENDER);	return_val_if_fail(err == 0, RET_FAIL);	glyph->code = code;	glyph->x    = priv->face->glyph->bitmap_left;	glyph->y    = priv->face->glyph->bitmap_top;	glyph->w    = priv->face->glyph->bitmap.width;	glyph->h    = priv->face->glyph->bitmap.rows;	glyph->advance_x = priv->face->glyph->advance.x >> 6;	glyph->data = priv->face->glyph->bitmap.buffer;    // For fix a bug-- the actual bitmap of some fonts is larger than it's font size	if (glyph->h > thiz->height(thiz)) {		ftk_logw("Bug font code: %04x/n", code);		glyph->h = thiz->height(thiz);	}	return RET_OK;}

static int      ftk_font_freetype_height(FtkFont* thiz){	DECL_PRIV(thiz, priv);	return_val_if_fail(thiz != NULL, 0);	return priv->size;}

static Ret  ftk_source_dfb_dispatch(FtkSource* thiz){	int i = 0;	int nr = 0;	DFBEvent   buff[10];	DECL_PRIV(thiz, priv);	DFBEvent* event = NULL;	int size =  read(priv->fd, buff, sizeof(buff));	return_val_if_fail(size > 0, RET_FAIL);	nr = size/sizeof(DFBEvent);	for(i = 0; i < nr; i++)	{		event = buff+i;		switch(event->clazz)		{			case DFEC_INPUT:			{				ftk_source_dfb_dispatch_input_event(thiz, &(event->input));				break;			}			case DFEC_USER:			{				break;			}			case DFEC_WINDOW:			{				break;			}			default:break;		}	}	return RET_OK;}