static void ftk_check_button_destroy(FtkWidget* thiz)
{
if(thiz != NULL)
{
DECL_PRIV0(thiz, priv);
ftk_bitmap_unref(priv->onimg);
ftk_bitmap_unref(priv->offimg);
FTK_ZFREE(priv, sizeof(PrivInfo));
}
return;
}
Ret ftk_check_button_set_image(FtkWidget* thiz, FtkBitmap* onimg, FtkBitmap* offimg)
{
DECL_PRIV0(thiz, priv);
return_val_if_fail(thiz != NULL, RET_FAIL);
ftk_bitmap_unref(priv->onimg);
ftk_bitmap_unref(priv->offimg);
priv->onimg = onimg;
ftk_bitmap_ref(priv->onimg);
priv->offimg = offimg;
ftk_bitmap_ref(priv->offimg);
return RET_OK;
}
int main(int argc, char* argv[])
{
ftk_backend_init(argc, argv);
ftk_set_allocator(ftk_allocator_default_create());
FtkDisplay* thiz = ftk_default_display();
if(thiz != NULL)
{
FtkBitmap* bitmap = NULL;
FtkColor color = {.a=0xff};
FtkRect rect = {0};
rect.width = ftk_display_width(thiz);
rect.height = ftk_display_height(thiz);
bitmap = ftk_bitmap_create(rect.width, rect.height, color);
red_bitmap(bitmap);
ftk_display_update(thiz, bitmap, &rect, 0, 0);
sleep(3);
green_bitmap(bitmap);
ftk_display_update(thiz, bitmap, &rect, 0, 0);
sleep(3);
blue_bitmap(bitmap);
ftk_display_update(thiz, bitmap, &rect, 0, 0);
sleep(3);
mire_bitmap(bitmap);
ftk_display_update(thiz, bitmap, &rect, 0, 0);
sleep(3);
ftk_display_destroy(thiz);
ftk_bitmap_unref(bitmap);
}
return 0;
}
static void ftk_app_music_destroy(FtkApp* thiz)
{
if(thiz != NULL)
{
DECL_PRIV(thiz, priv);
ftk_bitmap_unref(priv->icon);
FTK_FREE(thiz);
}
return;
}
static void ftk_scroll_bar_destroy(FtkWidget* thiz)
{
if(thiz != NULL)
{
DECL_PRIV0(thiz, priv);
ftk_bitmap_unref(priv->bitmap);
FTK_ZFREE(priv, sizeof(PrivInfo));
}
return;
}
Ret ftk_scroll_bar_set_bitmap(FtkWidget* thiz, FtkBitmap* bitmap)
{
DECL_PRIV0(thiz, priv);
return_val_if_fail(priv != NULL, RET_FAIL);
ftk_bitmap_unref(priv->bitmap);
priv->bitmap = bitmap;
ftk_bitmap_ref(priv->bitmap);
return RET_OK;
}
static void _app_music_create_button(FtkWidget *win, int x, int id, const char *icons)
{
FtkGc gc = {0};
char temp[100];
char path[FTK_MAX_PATH+1] = {0};
FtkWidget* button = NULL;
FtkBitmap* bitmap_normal = NULL;
FtkBitmap* bitmap_active = NULL;
FtkBitmap* bitmap_focus = NULL;
gc.mask = FTK_GC_BITMAP;
sprintf(temp, "icons/%s_normal.png", icons);
bitmap_normal = ftk_bitmap_factory_load(ftk_default_bitmap_factory(),
ftk_translate_path(temp, path));
sprintf(temp, "icons/%s_pressed.png", icons);
bitmap_active = ftk_bitmap_factory_load(ftk_default_bitmap_factory(),
ftk_translate_path(temp, path));
sprintf(temp, "icons/%s_selected.png", icons);
bitmap_focus = ftk_bitmap_factory_load(ftk_default_bitmap_factory(),
ftk_translate_path(temp, path));
button = ftk_button_create(win, x, 170, 68, 68);
ftk_widget_set_id(button, id);
ftk_button_set_clicked_listener(button, ftk_music_on_button_clicked, win);
gc.bitmap = bitmap_normal;
ftk_widget_set_gc(button, FTK_WIDGET_NORMAL, &gc);
gc.bitmap = bitmap_focus;
ftk_widget_set_gc(button, FTK_WIDGET_FOCUSED, &gc);
gc.bitmap = bitmap_active;
ftk_widget_set_gc(button, FTK_WIDGET_ACTIVE, &gc);
ftk_bitmap_unref(bitmap_normal);
ftk_bitmap_unref(bitmap_active);
ftk_bitmap_unref(bitmap_focus);
}
static Ret ftk_check_button_on_paint(FtkWidget* thiz)
{
int dx = 0;
int dy = 0;
int icon_w = 0;
int icon_h = 0;
FtkBitmap* bitmap = NULL;
DECL_PRIV0(thiz, priv);
const char** bg_imgs = NULL;
FTK_BEGIN_PAINT(x, y, width, height, canvas);
if (priv->onimg && priv->offimg) {
if (priv->checked)
bitmap = priv->onimg;
else
bitmap = priv->offimg;
}
else { // orignal code
if(priv->is_radio)
{
bg_imgs = priv->checked ? radio_bg_on_imgs : radio_bg_off_imgs;
}
else
{
bg_imgs = priv->checked ? check_bg_on_imgs : check_bg_off_imgs;
}
bitmap = ftk_theme_load_image(ftk_default_theme(), bg_imgs[ftk_widget_state(thiz)]);
}
return_val_if_fail(bitmap != NULL, RET_FAIL);
icon_w = ftk_bitmap_width(bitmap);
icon_h = ftk_bitmap_height(bitmap);
assert((icon_w) <= width && icon_h <= height);
dy = (height - icon_h) / 2;
dx = priv->icon_at_right ? width - icon_w : 0;
ftk_canvas_draw_bitmap_simple(canvas, bitmap, 0, 0, icon_w, icon_h, x + dx, y + dy);
if (NULL == priv->onimg)
ftk_bitmap_unref(bitmap);
if(ftk_widget_get_text(thiz) != NULL)
{
dy = height/2;
dx = priv->icon_at_right ? 2 : icon_w;
ftk_canvas_set_gc(canvas, ftk_widget_get_gc(thiz));
ftk_canvas_draw_string(canvas, x + dx, y + dy, ftk_widget_get_text(thiz), -1, 1);
}
FTK_END_PAINT();
}
static int lua_ftk_bitmap_unref(lua_State* L)
{
tolua_Error err = {0};
FtkBitmap* thiz;
int param_ok = tolua_isusertype(L, 1, "FtkBitmap", 0, &err);
return_val_if_fail(param_ok, 0);
thiz = tolua_tousertype(L, 1, 0);
ftk_bitmap_unref(thiz);
return 1;
}
int main(int argc, char* argv[])
{
FtkBitmap* bitmap = NULL;
const char* filename = argv[1];
FtkImageDecoder* thiz = ftk_image_jpeg_decoder_create();
assert(ftk_image_decoder_match(thiz, filename) == RET_OK);
assert((bitmap = ftk_image_decoder_decode(thiz, filename)) != NULL);
ftk_logd("w=%d h=%d\n", ftk_bitmap_width(bitmap), ftk_bitmap_height(bitmap));
ftk_bitmap_unref(bitmap);
ftk_image_decoder_destroy(thiz);
return 0;
}
Ret ftk_image_set_image(FtkWidget* thiz, FtkBitmap* image)
{
FtkGc gc = {0};
return_val_if_fail(thiz != NULL && image != NULL, RET_FAIL);
gc.mask = FTK_GC_BITMAP;
gc.bitmap = image;
ftk_widget_set_gc(thiz, FTK_WIDGET_INSENSITIVE, &gc);
ftk_bitmap_unref(image);
ftk_widget_invalidate(thiz);
return RET_OK;
}
static Ret designer_on_popup_menu(void* ctx, void* obj)
{
size_t i = 0;
int nr = 0;
int height = 0;
FtkBitmap* icon = NULL;
FtkWidget* popup = NULL;
FtkListItemInfo infos;
FtkWidget* win = (FtkWidget*)ctx;
memset(&infos, 0x00, sizeof(infos));
icon = ftk_theme_load_image(ftk_default_theme(), "info"FTK_STOCK_IMG_SUFFIX);
for(i = 0; i < FTK_ARRAY_SIZE(s_popup_menu_items); i++)
{
if(s_popup_menu_items[i].need_selected_widget && !designer_has_selected_widget(win))
{
continue;
}
nr++;
}
height = (nr + 1) * FTK_POPUP_MENU_ITEM_HEIGHT;
height = height < ftk_widget_height(win) ? height : ftk_widget_height(win);
popup = ftk_popup_menu_create(0, 0, 0, height, icon, _("Edit"));
infos.state = 0;
infos.type = FTK_LIST_ITEM_NORMAL;
for(i = 0; i < FTK_ARRAY_SIZE(s_popup_menu_items); i++)
{
if(s_popup_menu_items[i].need_selected_widget && !designer_has_selected_widget(win))
{
continue;
}
infos.value = i;
infos.text = s_popup_menu_items[i].name;
infos.extra_user_data = s_popup_menu_items[i].on_clicked;
ftk_popup_menu_add(popup, &infos);
}
ftk_bitmap_unref(icon);
ftk_popup_menu_set_clicked_listener(popup, designer_on_popup_menu_item_clicked, ctx);
ftk_widget_show_all(popup, 1);
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;
}
static void ftk_app_bluetooth_destroy(FtkApp* thiz)
{
if(thiz != NULL)
{
DECL_PRIV(thiz, priv);
ftk_bitmap_unref(priv->icon);
FTK_FREE(thiz);
if (_bt) {
bt_close(_bt);
_bt = NULL;
}
}
return;
}
FTK_HIDE int FTK_MAIN(int argc, char* argv[])
{
int width = 0;
int height = 0;
FtkWidget* win = NULL;
FtkWidget* button = NULL;
FtkWidget* icon_view = NULL;
FtkIconViewItem item;
FTK_INIT(argc, argv);
win = ftk_app_window_create();
ftk_window_set_animation_hint(win, "app_main_window");
width = ftk_widget_width(win);
height = ftk_widget_height(win);
button = ftk_button_create(win, 10, 0, width/3-10, 60);
ftk_widget_set_text(button, "more");
ftk_button_set_clicked_listener(button, button_more_clicked, win);
ftk_window_set_focus(win, button);
button = ftk_button_create(win, 2*width/3, 0, width/3-10, 60);
ftk_widget_set_text(button, "quit");
ftk_button_set_clicked_listener(button, button_quit_clicked, win);
ftk_window_set_focus(win, button);
item.icon = ftk_theme_load_image(ftk_default_theme(), "flag-32.png");
icon_view = ftk_icon_view_create(win, 5, 70, width-10, height-80);
ftk_widget_set_id(icon_view, 100);
ftk_icon_view_set_clicked_listener(icon_view, item_clicked, win);
for(; i < 4; i++)
{
char text[100] = {0};
ftk_snprintf(text, sizeof(text), "%d", i);
item.text = text;
item.user_data = (void*)i;
ftk_icon_view_add(icon_view, &item);
}
ftk_bitmap_unref(item.icon);
ftk_widget_set_text(win, "icon view demo");
ftk_widget_show_all(win, 1);
FTK_QUIT_WHEN_WIDGET_CLOSE(win);
FTK_RUN();
return 0;
}
static void ftk_wait_box_destroy(FtkWidget* thiz)
{
if(thiz != NULL)
{
DECL_PRIV0(thiz, priv);
if(priv->waiting)
{
ftk_wait_box_stop_waiting(thiz);
}
ftk_source_unref(priv->timer);
ftk_bitmap_unref(priv->bitmap);
FTK_ZFREE(priv, sizeof(PrivInfo));
}
return;
}
int main(int argc, char* argv[])
{
int i = 0;
int j = 0;
int width = 0;
int height = 0;
FtkGc gc = {0};
FtkWidget* win = NULL;
FtkWidget* button = NULL;
ftk_init(argc, argv);
width = ftk_display_width(ftk_default_display());
height = ftk_display_height(ftk_default_display());
gc.mask = FTK_GC_BITMAP;
win = ftk_window_create(0, 0, width, height);
for(i = 0; i < height/80; i++)
{
for(j = 0; j < width/80; j++)
{
gc.bitmap = ftk_bitmap_factory_load(ftk_default_bitmap_factory(), pngs[i + 1]);
button = ftk_button_create(1000, j * 80, i * 80, ftk_bitmap_width(gc.bitmap), ftk_bitmap_height(gc.bitmap));
ftk_widget_set_gc(button, FTK_WIDGET_NORMAL, &gc);
ftk_widget_set_gc(button, FTK_WIDGET_FOCUSED, &gc);
ftk_widget_append_child(win, button);
ftk_widget_show(button, 1);
ftk_bitmap_unref(gc.bitmap);
if(i == 0 && j == 0)
{
ftk_button_set_clicked_listener(button, button_clicked, NULL);
ftk_button_set_text(button, "Quit");
}
}
}
ftk_window_set_title(win, "button demo");
ftk_widget_show(win, 1);
ftk_run();
return 0;
}
int main(int argc, char* argv[])
{
FtkBitmap* bitmap = NULL;
FtkImageDecoder* decoder = NULL;
ftk_init(argc, argv);
decoder = ftk_image_bmp_decoder_create();
bitmap = ftk_image_decoder_decode(decoder, argv[1]);
if(bitmap != NULL)
{
printf("%s: width=%d height=%d\n", argv[1],
ftk_bitmap_width(bitmap), ftk_bitmap_height(bitmap));
ftk_bitmap_unref(bitmap);
}
ftk_image_decoder_destroy(decoder);
return 0;
}
static Ret button_more_clicked(void* ctx, void* obj)
{
int j = 0;
FtkIconViewItem item;
FtkWidget* icon_view = ftk_widget_lookup(ctx, 100);
item.icon = ftk_theme_load_image(ftk_default_theme(), "flag-32.png");
for(j=0; j < 4; j++)
{
char text[100] = {0};
ftk_snprintf(text, sizeof(text), "%d", i);
item.text = text;
ftk_bitmap_ref(item.icon);
item.user_data = (void*)i;
ftk_icon_view_add(icon_view, &item);
i+=1000;
}
ftk_bitmap_unref(item.icon);
return RET_OK;
}
int main(int argc, char* argv[])
{
FtkColor c = {0};
FtkBitmap* bitmap = NULL;
FtkBitmapFactory* f = NULL;
ftk_set_allocator(ftk_allocator_default_create());
if(argv[1] != NULL)
{
f = ftk_bitmap_factory_create();
bitmap = ftk_bitmap_factory_load(f, argv[1]);
c = ftk_bitmap_get_pixel(bitmap, 0, 0);
ftk_logi("r=%02x g=%02x b=%02x a=%02x\n", c.r, c.g, c.b, c.a);
ftk_bitmap_unref(bitmap);
ftk_bitmap_factory_destroy(f);
}
ftk_bitmap_auto_test();
return 0;
}
static void ftk_key_board_desc_destroy(FtkKeyBoardDesc* desc)
{
size_t v = 0;
size_t r = 0;
size_t c = 0;
if(desc != NULL)
{
ftk_key_board_desc_dump(desc);
for(v = 0 ; v < desc->view_nr; v++)
{
FtkKeyBoardView* view = desc->views+v;
for(r = 0; r < view->row_nr; r++)
{
FtkKeyBoardRow* row = view->rows+r;
for(c = 0; c < row->cell_nr; c++)
{
FtkKeyBoardCell* cell = row->cells+c;
ftk_bitmap_unref(cell->icon);
ftk_bitmap_unref(cell->bg_active);
ftk_bitmap_unref(cell->bg_normal);
}
FTK_FREE(row->cells);
}
FTK_FREE(view->rows);
ftk_bitmap_unref(view->bg);
ftk_bitmap_unref(view->cell_bg_active);
ftk_bitmap_unref(view->cell_bg_normal);
}
FTK_FREE(desc->views);
ftk_bitmap_unref(desc->candidates_vertical_line);
FTK_FREE(desc);
}
return;
}
static void ftk_list_render_default_destroy(FtkListRender* thiz)
{
if(thiz != NULL)
{
DECL_PRIV(thiz, priv);
ftk_bitmap_unref(priv->radio_on);
ftk_bitmap_unref(priv->radio_off);
ftk_bitmap_unref(priv->check_on);
ftk_bitmap_unref(priv->check_off);
ftk_bitmap_unref(priv->more);
ftk_bitmap_unref(priv->bg_disable);
if(priv->marquee_timer != NULL)
{
ftk_source_disable(priv->marquee_timer);
ftk_main_loop_remove_source(ftk_default_main_loop(), priv->marquee_timer);
}
FTK_ZFREE(thiz, sizeof(FtkListRender) + sizeof(PrivInfo));
}
return;
}
int ftk_message_box(FtkBitmap* icon, const char* title, const char* text, const char* buttons[FTK_MSGBOX_MAX_BUTTONS])
{
int i = 0;
int w = 0;
int h = 0;
int id = 0;
int ret = 0;
int width = 0;
int height = 0;
int xoffset = 0;
int yoffset = 0;
int h_margin = 0;
int has_title = icon != NULL || title != NULL;
int buttons_nr = ftk_count_strings(buttons);
FtkWidget* label = NULL;
FtkWidget* button = NULL;
FtkWidget* dialog = NULL;
return_val_if_fail(text != NULL, -1);
ftk_message_box_size(has_title, buttons_nr, text, &width, &height);
dialog = ftk_dialog_create(0, 0, width, height);
ftk_window_set_animation_hint(dialog, "msgbox");
if(has_title)
{
ftk_dialog_set_icon(dialog, icon);
ftk_widget_set_text(dialog, title);
}
else
{
ftk_dialog_hide_title(dialog);
ftk_widget_set_attr(dialog, FTK_ATTR_POPUP);
}
width = ftk_widget_width(dialog);
height = ftk_widget_height(dialog);
/*create label.*/
xoffset = FTK_H_MARGIN;
yoffset = FTK_V_MARGIN;
w = width - 2 * (FTK_DIALOG_BORDER + FTK_H_MARGIN);
h = height - FTK_DIALOG_BORDER - 4 * FTK_V_MARGIN;
h -= has_title ? ftk_dialog_get_title_height() : 0;
h -= buttons_nr > 0 ? FTK_BUTTON_DEFAULT_HEIGHT : 0;
label = ftk_label_create(dialog, xoffset, yoffset, w, h);
ftk_widget_set_text(label, text);
/*create buttons*/
if(buttons_nr > 0)
{
xoffset = 0;
w = FTK_BUTTON_DEFAULT_WIDTH;
h = FTK_BUTTON_DEFAULT_HEIGHT;
w = ((buttons_nr + 1) * w) < width ? w : (width / (buttons_nr + 1));
yoffset = height - h - FTK_V_MARGIN - (has_title ? ftk_dialog_get_title_height() : 0);
h_margin = (width - buttons_nr * w) / (buttons_nr + 1);
for(i = 0; i < buttons_nr; i++)
{
xoffset += h_margin;
button = ftk_button_create(dialog, xoffset, yoffset, w, h);
ftk_widget_set_id(button, i + 1);
ftk_widget_set_text(button, buttons[i]);
ftk_button_set_clicked_listener(button, message_box_on_button_clicked, &id);
xoffset += w;
}
}
else
{
/*if no buttons, quit when timeout.*/
ftk_dialog_quit_after(dialog, 3000);
}
ftk_widget_show_all(dialog, 1);
ret = ftk_dialog_run(dialog);
ftk_widget_unref(dialog);
if(icon != NULL)
{
ftk_bitmap_unref(icon);
}
return ret;
}
static void show_canvas(FtkDisplay* display, FtkCanvas* canvas)
{
FtkBitmap* bitmap = NULL;
FtkRect rect = {.x = 0, .y=0, .width=0, .height=0};
rect.width = ftk_display_width(display);
rect.height = ftk_display_height(display);
ftk_canvas_lock_buffer(canvas, &bitmap);
ftk_display_update(display, bitmap, &rect, 0, 0);
ftk_canvas_unlock_buffer(canvas);
return;
}
#if 1
void test_misc(FtkDisplay* display, FtkFont* font)
{
if(display != NULL)
{
int i = 0;
FtkGc gc = {0};
int extent = 0;
FtkColor color = {0x0, 0, 0, 0x0};
FtkRect rect = {.x = 0, .y=0, .width=0, .height=0};
rect.width = ftk_display_width(display);
rect.height = ftk_display_height(display);
gc.mask = FTK_GC_FG | FTK_GC_FONT;
gc.fg.a = 0xff;
gc.fg.r = 0x00;
gc.fg.g = 0x00;
gc.fg.b = 0xff;
gc.font = font;
FtkCanvas* thiz = ftk_canvas_create(rect.width, rect.height, &color);
show_canvas(display, thiz);
for(i = 0; i < ftk_display_height(display); i++)
{
if(gc.fg.r < 0xff)
{
gc.fg.r++;
}
else
{
gc.fg.g++;
}
ftk_canvas_set_gc(thiz, &gc);
ftk_canvas_draw_hline(thiz, 0, i, 320);
}
FtkBitmap* bitmap = ftk_bitmap_create(100, 100, color);
ftk_canvas_draw_bitmap_simple(thiz, bitmap, 0, 0, 100, 100, 100, 100);
ftk_canvas_draw_string(thiz, 0, 240, " Jim is a Programmer.", -1, 0);
gc.fg.b = 0xff;
ftk_canvas_set_gc(thiz, &gc);
ftk_canvas_draw_string(thiz, 0, 220, "李先静是一个程序员", -1, 0);
unsigned int line_mask = 0xaaaaaaaa;
gc.line_mask = line_mask;
gc.mask = FTK_GC_LINE_MASK;
ftk_canvas_set_gc(thiz, &gc);
show_canvas(display, thiz);
assert(ftk_canvas_font_height(thiz) == 16);
extent = ftk_canvas_get_extent(thiz, "李先静", -1);
printf("extent=%d\n", ftk_canvas_get_extent(thiz, "李先静", -1));
ftk_bitmap_unref(bitmap);
ftk_canvas_destroy(thiz);
}
sleep(3);
return;
}
#if 0
void test_draw_point(FtkDisplay* display)
{
int i = 0;
FtkGc gc = {.mask = FTK_GC_FG};
FtkRect rect = {0};
FtkColor color = {.a = 0xff};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, color);
rect.width = width;
rect.height = height;
color.r = 0xff;
color.a = 0xff;
gc.fg = color;
for(i = 0; i < width; i++)
{
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_point(thiz, i, 10);
}
color.g = 0xff;
color.r = 0;
for(i = 0; i < width; i++)
{
color.a = 0xff - (0xff & i);
gc.fg = color;
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_point(thiz, i, 20);
}
color.r = 0;
color.g = 0;
color.b = 0xff;
color.a = 0xff;
gc.fg = color;
gc.mask |= FTK_GC_ALPHA;
for(i = 0; i < width; i++)
{
gc.alpha = 0xff - (0xff & i);
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_point(thiz, i, 30);
}
show_canvas(display, thiz);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
#endif
void test_draw_vline(FtkDisplay* display)
{
int i = 0;
FtkGc gc = {.mask = FTK_GC_FG};
FtkRect rect = {0};
FtkColor color = {.a = 0xff};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
rect.width = width;
rect.height = height;
color.r = 0xff;
color.a = 0xff;
gc.fg = color;
for(i = 0; i < width; i++)
{
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_vline(thiz, i, 0, 20);
}
color.g = 0xff;
color.r = 0;
for(i = 0; i < width; i++)
{
color.a = 0xff - (0xff & i);
gc.fg = color;
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_vline(thiz, i, 30, 20);
}
color.r = 0;
color.g = 0;
color.b = 0xff;
color.a = 0xff;
gc.fg = color;
gc.mask |= FTK_GC_ALPHA;
for(i = 0; i < width; i++)
{
gc.alpha = 0xff - (0xff & i);
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_vline(thiz, i, 60, 20);
}
show_canvas(display, thiz);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
void test_draw_hline(FtkDisplay* display)
{
int i = 0;
FtkGc gc = {.mask = FTK_GC_FG};
FtkRect rect = {0};
FtkColor color = {.a = 0xff};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
rect.width = width;
rect.height = height;
color.r = 0xff;
color.a = 0xff;
gc.fg = color;
for(i = 0; i < height; i++)
{
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_hline(thiz, 0, i, 20);
}
color.g = 0xff;
color.r = 0;
for(i = 0; i < height; i++)
{
color.a = 0xff - (0xff & i);
gc.fg = color;
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_hline(thiz, 30, i, 20);
}
color.r = 0;
color.g = 0;
color.b = 0xff;
color.a = 0xff;
gc.fg = color;
gc.mask |= FTK_GC_ALPHA;
for(i = 0; i < height; i++)
{
gc.alpha = 0xff - (0xff & i);
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_hline(thiz, 60, i, 20);
}
show_canvas(display, thiz);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
#if 0
void test_draw_line(FtkDisplay* display)
{
int i = 0;
FtkGc gc = {.mask = FTK_GC_FG};
FtkRect rect = {0};
FtkColor color = {.a = 0xff};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, color);
rect.width = width;
rect.height = height;
color.r = 0xff;
color.a = 0xff;
gc.fg = color;
for(i = 0; i < height/2; i++)
{
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_line(thiz, 0, i, 20, i+10);
}
color.g = 0xff;
color.r = 0;
for(i = 0; i < height/2; i++)
{
color.a = 0xff - (0xff & i);
gc.fg = color;
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_line(thiz, 30, i, 50, i+10);
}
color.r = 0;
color.g = 0;
color.b = 0xff;
color.a = 0xff;
gc.fg = color;
gc.mask |= FTK_GC_ALPHA;
for(i = 0; i < height/2; i++)
{
gc.alpha = 0xff - (0xff & i);
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_line(thiz, 60, i, 80, i+10);
}
ftk_display_update(display, ftk_canvas_bitmap(thiz), &rect, 0, 0);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
#endif
void test_alpha(FtkDisplay* display)
{
int i = 0;
FtkGc gc = {.mask = FTK_GC_FG};
FtkRect rect = {0};
FtkColor color = {.a = 0xff};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
rect.width = width;
rect.height = height;
color.g = 0xff;
color.r = 0;
for(i = 0; i < 0xff; i += 4)
{
color.a = 0xff;
color.g = 0;
gc.fg = color;
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_rect(thiz, 0, 0, width, height, 0, 1);
color.a = 0xff - i;
color.g = 0xff;
gc.fg = color;
ftk_canvas_reset_gc(thiz, &gc);
ftk_canvas_draw_rect(thiz, 0, 0, width, height, 0, 1);
show_canvas(display, thiz);
usleep(200000);
}
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
void test_put_get_pixel(FtkDisplay* display)
{
int i = 0;
int j = 0;
FtkColor color = {.a=0xff, .r=0xef, .g=0xdf, .b=0xcf};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
for(i = 0; i < height; i++)
{
for(j = 0; j < width; j++)
{
FtkColor c = {0};
FtkColor* colorp = NULL;
colorp = &c;
assert(colorp->r == color.r);
assert(colorp->g == color.g);
assert(colorp->b == color.b);
assert(colorp->a == color.a);
}
}
ftk_canvas_destroy(thiz);
return;
}
void test_font(FtkDisplay* display, FtkFont* font)
{
int extent2 = 0;
FtkGc gc = {.mask = FTK_GC_FONT};
FtkColor color = {.a=0xff, .r=0xef, .g=0xdf, .b=0xcf};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
const char* str = "隐式声明与内建函数";
const char* other_side = NULL;
gc.font = font;
ftk_canvas_set_gc(thiz, &gc);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, 0, -1, 60);
assert(strcmp(other_side, "明与内建函数") == 0);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, other_side-str, -1, 60);
assert(strcmp(other_side, "建函数") == 0);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, other_side-str, -1, 60);
assert(strcmp(other_side, "") == 0);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, -1, other_side-str, 60);
assert(strcmp(other_side, "建函数") == 0);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, -1, other_side-str, 60);
assert(strcmp(other_side, "明与内建函数") == 0);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, -1, other_side-str, 60);
assert(strcmp(other_side, str) == 0);
other_side = ftk_canvas_calc_str_visible_range(thiz, str, -1, other_side-str, 60);
assert(strcmp(other_side, str) == 0);
printf("other_side = %s\n", other_side);
str = "Single line editor, that means you can input a one line only.";
extent2 = ftk_canvas_get_extent(thiz, str, -1);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
static void test_fill_bg(FtkDisplay* display)
{
FtkRect rect = {0};
FtkColor color = {.a=0xff, .r=0xef, .g=0xdf, .b=0xcf};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
FtkBitmap* bitmap = ftk_theme_load_image(ftk_default_theme(), "btn_default_pressed.9.png");
ftk_canvas_draw_bg_image(thiz, bitmap, FTK_BG_FOUR_CORNER, 10, 10, 100, 60);
ftk_canvas_draw_bg_image(thiz, bitmap, FTK_BG_FOUR_CORNER, 120, 10, 40, 60);
ftk_canvas_draw_bg_image(thiz, bitmap, FTK_BG_FOUR_CORNER, 10, 80, 20, 20);
ftk_canvas_draw_bg_image(thiz, bitmap, FTK_BG_FOUR_CORNER, 30, 80, 40, 20);
ftk_canvas_draw_bg_image(thiz, bitmap, FTK_BG_FOUR_CORNER, 80, 80, 60, 20);
rect.width = width;
rect.height = height;
show_canvas(display, thiz);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
static void test_draw_rect(FtkDisplay* display)
{
int i = 0;
FtkColor color = {.a = 0xff};
FtkRect rect = {0};
int width = ftk_display_width(display);
int height = ftk_display_height(display);
FtkGc gc = {.mask = FTK_GC_FG};
FtkCanvas* thiz = ftk_canvas_create(width, height, &color);
gc.fg.a = 0xff;
gc.fg.r = 0xff;
for(i = 0; i < width/8; i++)
{
gc.fg.r -= 0x10;
ftk_canvas_set_gc(thiz, &gc);
ftk_canvas_draw_rect(thiz, width * i/8, 0, width/8 - 1, height/8 - 1, 0, 1);
}
gc.fg.r = 0xff;
for(i = 0; i < width/8; i++)
{
gc.fg.r -= 0x10;
gc.fg.b += 0x10;
ftk_canvas_set_gc(thiz, &gc);
ftk_canvas_draw_rect(thiz, width * i/8, height/8, width/8 - 1, height/8 - 1, 0, 0);
}
gc.fg.r = 0xff;
for(i = 0; i < width/8; i++)
{
gc.fg.r -= 0x10;
ftk_canvas_set_gc(thiz, &gc);
ftk_canvas_draw_rect(thiz, width * i/8, height/4, width/8 - 1, height/8 - 1, 1, 1);
}
gc.fg.r = 0xff;
for(i = 0; i < width/8; i++)
{
gc.fg.r -= 0x10;
gc.fg.b += 0x10;
ftk_canvas_set_gc(thiz, &gc);
ftk_canvas_draw_rect(thiz, width * i/8, 3*height/8, width/8 - 1, height/8 - 1, 1, 0);
}
rect.width = width;
rect.height = height;
show_canvas(display, thiz);
ftk_canvas_destroy(thiz);
sleep(3);
return;
}
int main(int argc, char* argv[])
{
ftk_init(argc, argv);
FtkRect rect = {0};
FtkColor bg = {.a = 0xff};
FtkBitmap* bitmap = NULL;
FtkFont* font = ftk_default_font();
FtkDisplay* display = ftk_default_display();
rect.width = ftk_display_width(display);
rect.height = ftk_display_height(display);
#if 0
#else
test_draw_rect(display);
test_alpha(display);
test_draw_vline(display);
bitmap = ftk_bitmap_create(ftk_display_width(display), ftk_display_height(display), bg);
ftk_display_snap(display, &rect, bitmap);
test_draw_hline(display);
ftk_display_update(display, bitmap, &rect, 0, 0);
test_fill_bg(display);
test_font(display, font);
test_put_get_pixel(display);
test_draw_hline(display);
test_draw_vline(display);
ftk_bitmap_unref(bitmap);
#endif
ftk_run();
return 0;
}
#else
int main(int argc, char* argv[])
{
return 0;
}
