static Ret ftk_message_box_size(int has_title, int has_button, const char* text, int* w, int* h)
{
int start = 0;
int width = 0;
int height = 0;
int font_h = 0;
FtkRect rect = {0};
const char* end = text;
FtkCanvas* canvas = ftk_shared_canvas();
ftk_wnd_manager_get_work_area(ftk_default_wnd_manager(), &rect);
width = rect.width - 2 * (FTK_DIALOG_MARGIN + FTK_LABEL_LEFT_MARGIN + FTK_DIALOG_BORDER);
height = 4 * FTK_V_MARGIN + FTK_DIALOG_BORDER;
height += has_title ? ftk_dialog_get_title_height() : 0;
height += has_button ? FTK_BUTTON_DEFAULT_HEIGHT : 0;
font_h = ftk_font_desc_get_size(ftk_default_font());
while(*end != '\0')
{
height += font_h + FTK_LABEL_TOP_MARGIN;
end = ftk_canvas_calc_str_visible_range(canvas, text, start, -1, width, NULL);
start = end - text;
}
height = height < FTK_MESSAGE_BOX_MIN_HEIGHT ? FTK_MESSAGE_BOX_MIN_HEIGHT : height;
height = height < rect.height ? height : rect.height;
*h = (height + 1) & 0xfffffffe;
*w = (rect.width + 1) & 0xfffffffe;
return RET_OK;
}
extern "C" void Java_org_libftk_app_FtkActivity_onNativeResize(JNIEnv* env, jobject obj, jint width, jint height, jint format)
{
int w, h;
FtkDisplay* display = NULL;
FtkRotate r = FTK_ROTATE_0;
display = ftk_default_display();
r = ftk_display_get_rotate(display);
w = ftk_display_width(display);
h = ftk_display_height(display);
ftk_logd("onNativeResize() old size:%dX%d new size:%dX%d format:%d", w, h, width, height, format);
if(width != w && height != h)
{
memset(&jni.event, 0, sizeof(FtkEvent));
if(r == FTK_ROTATE_0)
{
jni.event.u.extra = (void*)FTK_ROTATE_90;
}
else
{
jni.event.u.extra = (void*)FTK_ROTATE_0;
}
jni.event.type = FTK_EVT_OS_SCREEN_ROTATED;
//ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &jni.event);
}
memset(&jni.event, 0, sizeof(FtkEvent));
jni.event.type = FTK_EVT_RELAYOUT_WND;
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &jni.event);
}
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 int lua_ftk_default_wnd_manager(lua_State* L)
{
FtkWndManager* retv;
retv = ftk_default_wnd_manager();
tolua_pushusertype(L, (FtkWndManager*)retv, "FtkWndManager");
return 1;
}
static Ret ftk_key_board_send_key(FtkWidget* thiz, FtkKeyBoardCell* cell)
{
FtkEvent event;
const char* key = NULL;
FtkKey code = FTK_KEY_0;
key = cell->action_args;
if(strlen(key) == 1)
{
code = (FtkKey)key[0];
}
else
{
/*FIXME*/
if(strcmp(key, "BACKSPACE") == 0)
{
code = FTK_KEY_BACKSPACE;
}
else if(strcmp(key, "DELETE") == 0)
{
code = FTK_KEY_DELETE;
}
else if(strcmp(key, "ENTER") == 0)
{
code = FTK_KEY_ENTER;
}
else
{
assert(!"not supported key.");
}
}
ftk_event_init(&event, FTK_EVT_KEY_DOWN);
event.u.key.code = code;
ftk_wnd_manager_dispatch_event(ftk_default_wnd_manager(), &event);
ftk_event_init(&event, FTK_EVT_KEY_UP);
event.u.key.code = code;
ftk_wnd_manager_dispatch_event(ftk_default_wnd_manager(), &event);
ftk_logd("%s:%d %s\n", __func__, __LINE__, cell->text);
return RET_OK;
}
static void ftk_init_panel(void)
{
FtkGc gc;
FtkWidget* item = NULL;
FtkWidget* panel = ftk_status_panel_create(FTK_STATUS_PANEL_HEIGHT);
size_t width = ftk_widget_width(panel);
ftk_set_status_panel(panel);
quit_if_fail(ftk_default_status_panel(), "Init status panel failed.\n");
memset(&gc, 0x00, sizeof(gc));
gc.mask = FTK_GC_BITMAP;
gc.bitmap = ftk_theme_load_image(ftk_default_theme(), "status-bg"FTK_STOCK_IMG_SUFFIX);
ftk_widget_set_gc(panel, FTK_WIDGET_NORMAL, &gc);
ftk_widget_set_gc(panel, FTK_WIDGET_ACTIVE, &gc);
ftk_widget_set_gc(panel, FTK_WIDGET_FOCUSED, &gc);
ftk_gc_reset(&gc);
item = ftk_status_item_create(panel, -100, 32);
ftk_widget_set_id(item, IDC_CLOSE_ITEM);
gc.bitmap = ftk_theme_load_image(ftk_default_theme(), "close-32"FTK_STOCK_IMG_SUFFIX);
if(gc.bitmap != NULL)
{
gc.mask = FTK_GC_BITMAP;
ftk_widget_set_gc(item, FTK_WIDGET_NORMAL, &gc);
ftk_widget_set_gc(item, FTK_WIDGET_FOCUSED, &gc);
ftk_gc_reset(&gc);
gc.mask = FTK_GC_BITMAP;
gc.bitmap = ftk_theme_load_image(ftk_default_theme(), "close-pressed-32"FTK_STOCK_IMG_SUFFIX);
ftk_widget_set_gc(item, FTK_WIDGET_ACTIVE, &gc);
ftk_gc_reset(&gc);
}
ftk_status_item_set_clicked_listener(item, button_close_top_clicked, NULL);
gc.bitmap = ftk_theme_load_image(ftk_default_theme(), "flag-32"FTK_STOCK_IMG_SUFFIX);
item = ftk_status_item_create(panel, 1, gc.bitmap ? min(ftk_bitmap_width(gc.bitmap), 100) : 32);
ftk_widget_set_id(item, IDC_ICON_ITEM);
if(gc.bitmap != NULL)
{
gc.mask = FTK_GC_BITMAP;
ftk_widget_set_gc(item, FTK_WIDGET_NORMAL, &gc);
ftk_widget_set_gc(item, FTK_WIDGET_ACTIVE, &gc);
ftk_widget_set_gc(item, FTK_WIDGET_FOCUSED, &gc);
ftk_gc_reset(&gc);
}
ftk_widget_show(item, 1);
item = ftk_status_item_create(panel, 2, width/2);
ftk_widget_set_id(item, IDC_TITLE_ITEM);
ftk_widget_show(item, 1);
ftk_wnd_manager_add_global_listener(ftk_default_wnd_manager(), on_wnd_manager_global_event, NULL);
ftk_widget_show(panel, 1);
return;
}
static Ret ftk_enable_curosr(void)
{
FtkSprite* sprite = ftk_sprite_create();
FtkBitmap* icon = ftk_theme_load_image(ftk_default_theme(), "cursor"FTK_STOCK_IMG_SUFFIX);
ftk_sprite_set_icon(sprite, icon);
ftk_sprite_show(sprite, 1);
ftk_wnd_manager_add_global_listener(ftk_default_wnd_manager(), ftk_move_cursor, sprite);
return RET_OK;
}
static Ret ftk_source_dfb_dispatch_input_event(FtkSource* thiz, DFBInputEvent* event)
{
DECL_PRIV(thiz, priv);
switch(event->type)
{
case DIET_KEYPRESS:
case DIET_KEYRELEASE:
{
priv->event.u.key.code = ftk_source_dfb_keymap(thiz, event->key_id);
priv->event.type = event->type == DIET_KEYPRESS ? FTK_EVT_KEY_DOWN : FTK_EVT_KEY_UP;
break;
}
case DIET_BUTTONPRESS:
case DIET_BUTTONRELEASE:
{
priv->event.type = event->type == DIET_BUTTONPRESS ? FTK_EVT_MOUSE_DOWN : FTK_EVT_MOUSE_UP;
priv->event.u.mouse.x = priv->x;
priv->event.u.mouse.y = priv->y;
break;
}
case DIET_AXISMOTION:
{
switch(event->axis)
{
case DIAI_Y:
{
priv->y = event->axisabs;
break;
}
case DIAI_X:
{
priv->x = event->axisabs;
break;
}
default:
{
break;
}
}
priv->event.type = FTK_EVT_MOUSE_MOVE;
priv->event.u.mouse.x = priv->x;
priv->event.u.mouse.y = priv->y;
break;
}
default:break;
}
if(priv->event.type != FTK_EVT_NOP)
{
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &priv->event);
priv->event.type = FTK_EVT_NOP;
}
return RET_OK;
}
static Ret ftk_input_method_win32_deactivate(FtkInputMethod* thiz)
{
ftk_input_method_win32_reset(thiz);
ftk_wnd_manager_remove_global_listener(ftk_default_wnd_manager(),
(FtkListener)ftk_input_method_win32_handle_event, thiz);
ftk_logd("%s\n", __func__);
return RET_OK;
}
extern "C" void Java_org_libftk_app_FtkActivity_onNativeKey(JNIEnv* env, jobject obj, jint action, jint keyCode)
{
ftk_logd("native key action:%d keyCode:%d", action, keyCode);
if(action == 2)
{
return;
}
jni.event.type = action == 0 ? FTK_EVT_KEY_DOWN : FTK_EVT_KEY_UP;
jni.event.u.key.code = key_maps[keyCode];
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &jni.event);
}
static void ftk_source_touch_init(void)
{
FtkSource* source = NULL;
source = ftk_source_touch_create(FTK_TOUCH_NAME,
(FtkOnEvent)ftk_wnd_manager_queue_event_auto_rotate, ftk_default_wnd_manager());
if (source != NULL)
{
ftk_sources_manager_add(ftk_default_sources_manager(), source);
}
ftk_logd("%s: touch dev %s source=%p\n", __func__, FTK_TOUCH_NAME, source);
}
static Ret ftk_menu_panel_on_event(FtkWidget* thiz, FtkEvent* event)
{
Ret ret = RET_OK;
DECL_PRIV1(thiz, priv);
if(event->type == FTK_EVT_KEY_UP && event->u.key.code == FTK_KEY_MENU)
{
ftk_widget_unref(thiz);
return ret;
}
if(event->type == FTK_EVT_SHOW)
{
ftk_wnd_manager_grab(ftk_default_wnd_manager(), thiz);
}
if(event->type == FTK_EVT_HIDE)
{
ftk_wnd_manager_ungrab(ftk_default_wnd_manager(), thiz);
}
if((event->type == FTK_EVT_MOUSE_UP && ret != RET_IGNORED)
|| (event->type == FTK_EVT_KEY_UP && FTK_IS_ACTIVE_KEY(event->u.key.code)))
{
ftk_widget_show(thiz, 0);
}
ret = priv->parent_on_event(thiz, event);
if((event->type == FTK_EVT_MOUSE_UP && ret != RET_IGNORED)
|| (event->type == FTK_EVT_KEY_UP && FTK_IS_ACTIVE_KEY(event->u.key.code)))
{
ftk_widget_unref(thiz);
}
return ret;
}
static Ret ftk_input_method_hw_deactivate(FtkInputMethod* thiz)
{
DECL_PRIV(thiz, priv);
ftk_input_method_hw_end(thiz);
ftk_input_method_hw_reset(thiz);
ftk_hand_write_engine_deactivate(priv->engine);
ftk_wnd_manager_remove_global_listener(ftk_default_wnd_manager(),
(FtkListener)ftk_input_method_hw_handle_event, thiz);
ftk_logd("%s\n", __func__);
return RET_OK;
}
static void ftk_display_android_destroy(FtkDisplay* thiz)
{
if(thiz != NULL)
{
DECL_PRIV(thiz, priv);
ftk_wnd_manager_remove_global_listener(ftk_default_wnd_manager(),
(FtkListener)ftk_display_android_handle_event, thiz);
ftk_bitmap_unref(priv->bitmap);
FTK_ZFREE(thiz, sizeof(FtkDisplay) + sizeof(PrivInfo));
}
return;
}
Ret ftk_input_method_hw_set_rect(FtkInputMethod* thiz, FtkRect* rect)
{
DECL_PRIV(thiz, priv);
return_val_if_fail(priv != NULL, RET_FAIL);
if(rect != NULL)
{
priv->rect = *rect;
}
else
{
ftk_wnd_manager_get_work_area(ftk_default_wnd_manager(), &(priv->rect));
}
ftk_stroke_painter_set_rect(priv->painter, &(priv->rect));
ftk_hand_write_engine_set_rect(priv->engine, &(priv->rect));
return RET_OK;
}
extern "C" void Java_org_libftk_app_FtkActivity_onNativeCommitText(JNIEnv* env, jobject obj, jstring text, jint newCursorPosition)
{
char* buf;
jsize len;
const char *str;
len = env->GetStringUTFLength(text);
str = env->GetStringUTFChars(text, NULL);
buf = (char*)FTK_ALLOC(len + 1);
memcpy(buf, str, len);
buf[len] = '\0';
env->ReleaseStringUTFChars(text, str);
memset(&jni.event, 0, sizeof(FtkEvent));
jni.event.u.extra = buf;
jni.event.type = FTK_EVT_OS_IM_COMMIT;
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &jni.event);
}
static Ret ftk_display_android_handle_event(FtkDisplay* thiz, FtkEvent* event)
{
Ret ret = RET_OK;
DECL_PRIV(thiz, priv);
return_val_if_fail(priv != NULL && event != NULL, RET_FAIL);
switch(event->type)
{
case FTK_EVT_OS_SCREEN_ROTATED:
{
ftk_wnd_manager_set_rotate(ftk_default_wnd_manager(), (FtkRotate)event->u.extra);
ret = RET_REMOVE;
break;
}
default:break;
}
return ret;
}
static void on_key_event(rfbBool down, rfbKeySym key, rfbClientPtr cl)
{
int code = 0;
if(key < 0x100)
{
code = s_key_map[key];
}
else
{
code = s_ctl_key_map[0xff & key];
}
ftk_logd("%s: %02x -- > %02x\n", __func__, key, code);
g_vnc_context.event.type = down ? FTK_EVT_KEY_DOWN : FTK_EVT_KEY_UP;
g_vnc_context.event.u.key.code = code;
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &g_vnc_context.event);
return;
}
static void on_pointer_event(int buttonMask, int x,int y, rfbClientPtr cl)
{
if(x >=0 && y >=0 && x < g_vnc_context.max_x && y < g_vnc_context.max_y)
{
g_vnc_context.event.type = FTK_EVT_NOP;
g_vnc_context.event.u.mouse.x = x;
g_vnc_context.event.u.mouse.y = y;
if(buttonMask)
{
if(g_vnc_context.old_button==buttonMask)
{
printf("move %d %d\n", x, y);
g_vnc_context.event.type = FTK_EVT_MOUSE_MOVE;
} else
{
printf("press %d %d\n", x, y);
g_vnc_context.event.type = FTK_EVT_MOUSE_DOWN;
}
}
else
{
if(g_vnc_context.old_button)
{
printf("up %d %d\n", x, y);
g_vnc_context.event.type = FTK_EVT_MOUSE_UP;
}
g_vnc_context.old_button=0;
}
g_vnc_context.old_x=x; g_vnc_context.old_y=y; g_vnc_context.old_button=buttonMask;
if(g_vnc_context.event.type != FTK_EVT_NOP)
{
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &g_vnc_context.event);
}
}
rfbDefaultPtrAddEvent(buttonMask, x, y, cl);
return;
}
extern "C" void Java_org_libftk_app_FtkActivity_onNativeTouch(JNIEnv* env, jobject obj, jint action, jfloat x, jfloat y, jfloat p)
{
ftk_logd("native touch event %d @ %f/%f, pressure %f", action, x, y, p);
memset(&jni.event, 0, sizeof(FtkEvent));
if(action==0)
{
jni.event.type = FTK_EVT_MOUSE_DOWN;
}
else if(action == 1 || action == 3)
{
jni.event.type = FTK_EVT_MOUSE_UP;
}
else if(action == 2)
{
jni.event.type = FTK_EVT_MOUSE_MOVE;
}
else
{
return;
}
jni.event.u.mouse.x = x;
jni.event.u.mouse.y = y;
ftk_wnd_manager_queue_event_auto_rotate(ftk_default_wnd_manager(), &jni.event);
}
static Ret ftk_init_input(void)
{
char filename[260] = {0};
const char* tsdev = NULL;
FtkSource* source = NULL;
struct dirent* iter = NULL;
const char* extra_input = NULL;
struct stat buf;
DIR* dir = opendir("/dev/input");
return_val_if_fail(dir != NULL, RET_FAIL);
tsdev = getenv("FTK_TSLIB_FILE") ? getenv("FTK_TSLIB_FILE") : FTK_TSLIB_FILE;
while((iter = readdir(dir)) != NULL)
{
if(iter->d_name[0] == '.')
continue;
ftk_snprintf(filename, sizeof(filename), "/dev/input/%s", iter->d_name);
if (stat(filename, &buf) == -1)
{
perror("stat");
continue;
}
//if(!(iter->d_type & DT_CHR)) continue;
if(!(buf.st_mode & S_IFCHR))
continue;
#ifdef USE_TSLIB
if(strcmp(filename, tsdev) == 0)
{
/*skip tsdev now, open it later.*/
continue;
}
else
#endif
if(strcmp(filename, "/dev/input/mice") == 0)
{
int max_x = ftk_display_width(ftk_default_display());
int max_y = ftk_display_height(ftk_default_display());
source = ftk_source_ps2mouse_create(filename,
(FtkOnEvent)ftk_wnd_manager_queue_event_auto_rotate, ftk_default_wnd_manager(), max_x, max_y);
}
else
{
source = ftk_source_input_create(filename,
(FtkOnEvent)ftk_wnd_manager_queue_event_auto_rotate, ftk_default_wnd_manager());
}
if(source != NULL)
{
ftk_sources_manager_add(ftk_default_sources_manager(), source);
}
}
closedir(dir);
#ifdef USE_TSLIB
source = ftk_source_tslib_create(tsdev,
(FtkOnEvent)ftk_wnd_manager_queue_event_auto_rotate, ftk_default_wnd_manager());
if(source != NULL)
{
ftk_sources_manager_add(ftk_default_sources_manager(), source);
}
ftk_logd("%s: tsdev %s source=%p\n", __func__, tsdev, source);
#endif
extra_input = getenv("FTK_EXTRA_INPUT");
if(extra_input != NULL)
{
source = ftk_source_input_create(filename,
(FtkOnEvent)ftk_wnd_manager_queue_event_auto_rotate, ftk_default_wnd_manager());
if(source != NULL)
{
ftk_sources_manager_add(ftk_default_sources_manager(), source);
ftk_logd("add %s input device\n", extra_input);
}
}
return RET_OK;
}
void ftk_deinit(void)
{
if(ftk_default_input_method_preeditor() != NULL)
{
ftk_input_method_preeditor_destroy(ftk_default_input_method_preeditor());
}
if(ftk_default_wnd_manager() != NULL)
{
ftk_wnd_manager_destroy(ftk_default_wnd_manager());
}
if(ftk_default_main_loop() != NULL)
{
ftk_main_loop_destroy(ftk_default_main_loop());
}
if(ftk_default_sources_manager() != NULL)
{
ftk_sources_manager_destroy(ftk_default_sources_manager());
}
if(ftk_default_bitmap_factory() != NULL)
{
ftk_bitmap_factory_destroy(ftk_default_bitmap_factory());
}
if(ftk_default_text_layout() != NULL)
{
ftk_text_layout_destroy(ftk_default_text_layout());
}
if(ftk_default_display() != NULL)
{
ftk_display_destroy(ftk_default_display());
}
if(ftk_default_theme() != NULL)
{
ftk_theme_destroy(ftk_default_theme());
}
if(ftk_shared_canvas() != NULL)
{
ftk_canvas_destroy(ftk_shared_canvas());
}
if(ftk_default_input_method_manager() != NULL)
{
ftk_input_method_manager_destroy(ftk_default_input_method_manager());
}
if(ftk_default_config() != NULL)
{
ftk_config_destroy(ftk_default_config());
}
ftk_platform_deinit();
#ifndef USE_STD_MALLOC
if(ftk_default_allocator() != NULL)
{
ftk_allocator_destroy(ftk_default_allocator());
}
#endif
ftk_logd("%s: ftk exit.\n", __func__);
ftk_clear_globals();
return;
}
/*
* guest the mouse event is a click event or handwrite stroke.
* click: during specified time, the mouse don't move out of specified range.
*/
static Ret ftk_input_method_hw_click_check(FtkInputMethod* thiz)
{
int i = 0;
DECL_PRIV(thiz, priv);
if(priv->points_nr < 3)
{
priv->hand_write_state = FTK_HW_NONE;
}
else
{
priv->hand_write_state = FTK_HW_NONE;
for(i = 1; i < priv->points_nr; i++)
{
if(FTK_ABS(priv->points[0].x - priv->points[i].x) > FTK_HW_CLICK_RANGE
|| FTK_ABS(priv->points[0].y - priv->points[i].y) > FTK_HW_CLICK_RANGE)
{
priv->hand_write_state = FTK_HW_WRITING;
break;
}
}
}
/*It is click event, re-dispatch the events.*/
if(priv->hand_write_state == FTK_HW_NONE)
{
FtkEvent event = {0};
int points_nr = priv->points_nr;
ftk_wnd_manager_remove_global_listener(ftk_default_wnd_manager(),
(FtkListener)ftk_input_method_hw_handle_event, thiz);
event.type = FTK_EVT_MOUSE_DOWN;
event.u.mouse.x = priv->points[0].x;
event.u.mouse.y = priv->points[0].y;
ftk_wnd_manager_dispatch_event(ftk_default_wnd_manager(), &event);
for(i = 1; i < (points_nr - 1); i++)
{
event.type = FTK_EVT_MOUSE_MOVE;
event.u.mouse.x = priv->points[i].x;
event.u.mouse.y = priv->points[i].y;
ftk_wnd_manager_dispatch_event(ftk_default_wnd_manager(), &event);
}
if(points_nr > 1)
{
event.type = priv->pen_down ? FTK_EVT_MOUSE_MOVE : FTK_EVT_MOUSE_UP;
event.u.mouse.x = priv->points[i].x;
event.u.mouse.y = priv->points[i].y;
ftk_wnd_manager_dispatch_event(ftk_default_wnd_manager(), &event);
}
ftk_wnd_manager_add_global_listener(ftk_default_wnd_manager(),
(FtkListener)ftk_input_method_hw_handle_event, thiz);
ftk_input_method_hw_end(thiz);
ftk_input_method_hw_reset(thiz);
ftk_logd("%s: it is click event.\n", __func__);
}
else
{
ftk_stroke_painter_show(priv->painter, 1);
ftk_stroke_painter_update(priv->painter, NULL);
ftk_logd("%s: it is handwrite stroke\n", __func__);
}
return RET_REMOVE;
}
Ret ftk_init(int argc, char* argv[])
{
FtkColor bg = {0};
FtkConfig* config = NULL;
FtkDisplay* display = NULL;
static int ftk_inited = 0;
if(ftk_inited)
{
return RET_OK;
}
else
{
ftk_inited = 1;
}
ftk_clear_globals();
PROFILE_START();
#ifndef USE_STD_MALLOC
ftk_set_allocator(FTK_ALLOC_PROFILE(ftk_allocator_default_create()));
quit_if_fail(ftk_default_allocator(), "Init allocator failed.\n");
#endif
ftk_platform_init(argc, argv);
config = ftk_config_create();
ftk_set_config(config);
ftk_config_init(config, argc, argv);
quit_if_fail(ftk_default_config(), "Init config failed.\n");
PROFILE_END("config init");
ftk_set_text_layout(ftk_text_layout_create());
PROFILE_START();
ftk_set_sources_manager(ftk_sources_manager_create(64));
ftk_set_main_loop(ftk_main_loop_create(ftk_default_sources_manager()));
ftk_set_wnd_manager(ftk_wnd_manager_default_create(ftk_default_main_loop()));
quit_if_fail(ftk_default_wnd_manager(), "Init windows manager failed.\n");
PROFILE_END("source main loop wnd manager init");
ftk_init_bitmap_factory();
PROFILE_START();
ftk_init_theme(ftk_config_get_theme(config));
ftk_backend_init(argc, argv);
PROFILE_END("theme and backend init");
display = ftk_display_rotate_create(ftk_default_display(), ftk_config_get_rotate(ftk_default_config()));
ftk_set_display(display);
quit_if_fail(ftk_default_display(), "Init display failed.\n");
PROFILE_START();
bg.a = 0xff;
ftk_set_shared_canvas(ftk_canvas_create(ftk_display_width(display), ftk_display_height(display), &bg));
ftk_logd("canvas init: %d %d\n", ftk_display_width(display), ftk_display_height(display));
PROFILE_END("canvas init");
PROFILE_START();
ftk_set_input_method_manager(ftk_input_method_manager_create());
ftk_set_input_method_preeditor(ftk_input_method_preeditor_default_create());
quit_if_fail(ftk_default_input_method_manager(), "Init input method failed.\n");
PROFILE_END("input method init");
PROFILE_START();
if(ftk_config_get_enable_status_bar(config))
{
ftk_init_panel();
}
PROFILE_END("panel init");
if(ftk_config_get_enable_cursor(config))
{
#ifndef USE_LINUX_DFB
ftk_enable_curosr();
#endif
}
return RET_OK;
}
static Ret ftk_init_input(void)
{
const char* tsdev = NULL;
FtkSource* source = NULL;
source = ftk_source_input_create((FtkOnEvent)ftk_wnd_manager_queue_event_auto_rotate, ftk_default_wnd_manager());
if(source != NULL)
{
ftk_sources_manager_add(ftk_default_sources_manager(), source);
}
return RET_OK;
}
