LCUI_API int Graph_FillImage( LCUI_Graph *graph,
LCUI_Graph *bg,
int mode,
LCUI_RGB color )
{
LCUI_Size size;
LCUI_Pos pos;
LCUI_Graph temp_bg;
LCUI_BOOL replace_mix;
if( Check_Option( mode, GRAPH_MIX_FLAG_REPLACE ) ) {
/* 将alpha通道置为0 */
Graph_FillAlpha( graph, 0 );
replace_mix = TRUE;
} else {
/* 填充背景色，将alpha通道置为255 */
Graph_FillColor( graph, color );
Graph_FillAlpha( graph, 255 );
replace_mix = FALSE;
}
if(!Graph_IsValid(bg) || !Graph_IsValid(graph)) {
return -1;
}
size.w = graph->w;
size.h = graph->h;
Graph_Init(&temp_bg);
pos.x = pos.y = 0;
/* 平铺 */
if( Check_Option( mode, LAYOUT_TILE ) ) {
return Graph_Tile( bg, graph, replace_mix );
}
/* 缩放 */
if( Check_Option( mode, LAYOUT_ZOOM ) ) {
Graph_Zoom( bg, &temp_bg, TRUE, size );
pos.x = (size.w - temp_bg.w) / 2.0;
pos.y = (size.h - temp_bg.h) / 2.0;
bg = &temp_bg;
}
/* 拉伸 */
else if( Check_Option( mode, LAYOUT_STRETCH ) ) {
Graph_Zoom( bg, &temp_bg, FALSE, size );
bg = &temp_bg;
}
/* 居中 */
else if( Check_Option( mode, LAYOUT_CENTER ) ) {
pos.x = (size.w - bg->w) / 2.0;
pos.y = (size.h - bg->h) / 2.0;
}
if( replace_mix ) {
Graph_Replace( graph, bg, pos );
} else {
Graph_Mix( graph, bg, pos );
}
Graph_Free( &temp_bg );
return 0;
}
LCUI_API int Graph_PutImage( LCUI_Graph *graph, LCUI_Graph *image, int flag )
{
LCUI_Pos pos;
if(!Graph_IsValid(graph) || ! Graph_IsValid(image)) {
return -1;
}
pos.x = pos.y = 0;
if((flag & ALIGN_TOP_LEFT) == ALIGN_TOP_LEFT); /* 左上角对齐 */
else if((flag & ALIGN_TOP_CENTER) == ALIGN_TOP_CENTER) {
/* 向上中间对齐 */
pos.x = (graph->w - image->w) / 2;
}/* 向右上角对齐 */
else if((flag & ALIGN_TOP_RIGHT) == ALIGN_TOP_RIGHT) {
pos.x = graph->w - image->w;
}/* 向中央偏左对齐 */
else if((flag & ALIGN_MIDDLE_LEFT) == ALIGN_MIDDLE_LEFT) {
pos.y = (graph->h - image->h) / 2;
}/* 向正中央对齐 */
else if((flag & ALIGN_MIDDLE_CENTER) == ALIGN_MIDDLE_CENTER) {
pos.x = (graph->w - image->w) / 2;
pos.y = (graph->h - image->h) / 2;
}/* 向中央偏右对齐 */
else if((flag & ALIGN_MIDDLE_RIGHT) == ALIGN_MIDDLE_RIGHT) {
pos.x = graph->w - image->w;
pos.y = (graph->h - image->h) / 2;
}/* 向底部偏左对齐 */
else if((flag & ALIGN_BOTTOM_LEFT) == ALIGN_BOTTOM_LEFT) {
pos.y = graph->h - image->h;
}/* 向底部居中对齐 */
else if((flag & ALIGN_BOTTOM_CENTER) == ALIGN_BOTTOM_CENTER) {
pos.x = (graph->w - image->w) / 2;
pos.y = graph->h - image->h;
}/* 向底部偏右对齐 */
else if((flag & ALIGN_BOTTOM_RIGHT) == ALIGN_BOTTOM_RIGHT) {
pos.x = graph->w - image->w;
pos.y = graph->h - image->h;
}
if( Check_Option(flag, GRAPH_MIX_FLAG_OVERLAY) ) {
/* 如果包含GRAPH_MIX_FLAG_OVERLAY选项 */
Graph_Mix(graph, image, pos);
}
else if( Check_Option(flag, GRAPH_MIX_FLAG_REPLACE) ) {
/* 如果包含GRAPH_MIX_FLAG_REPLACE选项 */
Graph_Replace(graph, image, pos);
} else {
Graph_Mix(graph, image, pos);
}
return 0;
}
static void
TextBox_Input( LCUI_Widget *widget, LCUI_WidgetEvent *event )
{
static char buff[5];
static int cols, flag, rows;
static LCUI_Pos cur_pos;
static LCUI_TextLayer *layer;
static LCUI_TextBox *textbox;
//_DEBUG_MSG("you input: %d\n", event->key.key_code);
layer = TextBox_GetTextLayer( widget );
textbox = Widget_GetPrivData( widget );
cur_pos = TextLayer_Cursor_GetPos( layer );
cols = TextLayer_GetRowLen( layer, cur_pos.y );
rows = TextLayer_GetRows( layer );
switch( event->key.key_code ) {
case LCUIKEY_HOMEPAGE: //home键移动光标至行首
cur_pos.x = 0;
goto mv_cur_pos;
case LCUIKEY_END: //end键移动光标至行尾
cur_pos.x = cols;
goto mv_cur_pos;
case LCUIKEY_LEFT:
if( cur_pos.x > 0 ) {
cur_pos.x--;
} else if( cur_pos.y > 0 ) {
cur_pos.y--;
cur_pos.x = TextLayer_GetRowLen( layer, cur_pos.y );
}
goto mv_cur_pos;
case LCUIKEY_RIGHT:
if( cur_pos.x < cols ) {
cur_pos.x++;
} else if( cur_pos.y < rows-1 ) {
cur_pos.y++;
cur_pos.x = 0;
}
goto mv_cur_pos;
case LCUIKEY_UP:
if( cur_pos.y > 0 ) {
cur_pos.y--;
}
goto mv_cur_pos;
case LCUIKEY_DOWN:
if( cur_pos.y < rows-1 ) {
cur_pos.y++;
}
mv_cur_pos:;
/* 移动光标位置 */
if( textbox->show_placeholder ) {
cur_pos.x = cur_pos.y = 0;
}
TextBox_Cursor_Move( widget,cur_pos );
break;
case LCUIKEY_BACKSPACE: //删除光标左边的字符
TextBox_Text_Backspace( widget, 1 );
break;
case LCUIKEY_DELETE:
//删除光标右边的字符
break;
default:;
if( textbox->limit_mode == 0 ) {
flag = 1;
} else {
flag = 0;
}
/* 处理文本框的字符输入限制 */
if( Check_Option( textbox->limit_mode, ONLY_0_TO_9 ) ) {
if( event->key.key_code >= '0'
&& event->key.key_code <= '9' ) {
++flag;
}
}
if( Check_Option( textbox->limit_mode, ONLY_a_TO_z ) ) {
if( event->key.key_code >= 'a'
&& event->key.key_code <= 'z' ) {
++flag;
}
}
if( Check_Option( textbox->limit_mode, ONLY_A_TO_Z ) ) {
if( event->key.key_code >= 'A'
&& event->key.key_code <= 'Z' ) {
++flag;
}
}
if( Check_Option( textbox->limit_mode, ONLY_UNDERLINE ) ) {
if( event->key.key_code == '_' ) {
++flag;
}
}
//_DEBUG_MSG("input char: %c, %d\n", event->key.key_code, flag);
/* 如果该ASCII码代表的字符是可见的 */
if( flag == 1 && (event->key.key_code == 10 ||
(event->key.key_code > 31
&& event->key.key_code < 126)) ) {
//wchar_t *text;
buff[0] = event->key.key_code;
buff[1] = 0;
TextBox_Text_Add( widget, buff);
//text = TextLayer_Get_Text( layer );
//free( text );
}
//向文本框中添加字符
break;
}
}
int
AppTask_Custom_Add(int mode, LCUI_Func *func_data)
/*
* 功能：使用自定义方式添加程序任务
* 用法示例：
* 在函数的各参数与队列中的函数及各参数不重复时，添加它
* AppTask_Custom_Add(ADD_MODE_NOT_REPEAT | AND_ARG_F | AND_ARG_S, func_data);
* 只要函数和参数1不重复则添加
* AppTask_Custom_Add(ADD_MODE_NOT_REPEAT | AND_ARG_F, func_data);
* 要函数不重复则添加
* AppTask_Custom_Add(ADD_MODE_NOT_REPEAT, func_data);
* 添加新的，不管是否有重复的
* AppTask_Custom_Add(ADD_MODE_ADD_NEW, func_data);
* 有相同函数则覆盖，没有则新增
* AppTask_Custom_Add(ADD_MODE_REPLACE, func_data);
* */
{
int total, i;
/* 先获取程序数据结构体指针 */
LCUI_App *app;
LCUI_FuncQueue *queue;
LCUI_Func *temp = NULL;
if( func_data->id == (LCUI_ID)0 ) {
app = Get_Self_AppPointer();
} else {
app = Find_App( func_data->id );
}
if( !app ) {
return -1;
}
queue = &app->task_queue;
total = Queue_Get_Total(queue);
/* 如果模式是“添加新的”模式 */
if( mode == ADD_MODE_ADD_NEW ) {
Queue_Add(queue, func_data);
return 0;
}
//printf("mode: %d\n", mode);
for (i = 0; i < total; ++i) {
//printf("1\n");
temp = Queue_Get(queue, i);
/* 如果指针无效，或者函数指针已有记录 */
if( !temp || temp->func != func_data->func ) {
continue;
}
/* 如果要求的是不重复模式 */
if(Check_Option(mode, ADD_MODE_NOT_REPEAT)) {
/* 如果要求是第1个参数不能重复 */
if(Check_Option(mode, AND_ARG_F)) {
//printf("ADD_MODE_NOT_REPEAT, AND_ARG_F\n");
//printf("old:%p, new:%p\n", queue->queue[i].arg_f, arg_f);
/* 如果要求是第2个参数也不能重复 */
if(Check_Option(mode, AND_ARG_S)) {
/* 如果函数以及参数1和2都一样 */
if(temp->arg[0] == func_data->arg[0]
&& temp->arg[1] == func_data->arg[1]) {
__destroy_apptask( func_data );
return -1;
}
} else {/* 否则，只是要求函数以及第1个参数不能全部重复 */
if(temp->arg[0] == func_data->arg[0]) {
__destroy_apptask( func_data );
return -1;
}
}
}/* 否则，如果只是要求是第2个参数不能重复 */
else if(Check_Option(mode, AND_ARG_S)) {
if(temp->arg[1] == func_data->arg[1] ) {
__destroy_apptask( func_data );
return -1;
}
} else {/* 否则，只是要求函数不同 */
__destroy_apptask( func_data );
return -1;
}
}/* 如果要求的是替换模式 */
else if(Check_Option(mode, ADD_MODE_REPLACE)) {
//printf("ADD_MODE_REPLACE\n");
/* 如果要求是第1个参数相同 */
if( Check_Option(mode, AND_ARG_F) ) {
/* 如果要求是第2个参数也相同 */
if( Check_Option(mode, AND_ARG_S) ) {
if(temp->arg[0] == func_data->arg[0]
&& temp->arg[1] == func_data->arg[1]
) {
break;
}
} else {/* 否则，只是要求函数以及第1个参数全部相同 */
if(temp->arg[0] == func_data->arg[0]) {
// printf("ARG_F\n");
break;
}
}
}/* 否则，如果只是要求第2个参数不能相同 */
else if(Check_Option(mode, AND_ARG_S)) {
if(temp->arg[1] == func_data->arg[1]) {
break;
}
} else {
break;
}
}
}
if(i == total) {
Queue_Add(queue, func_data);
} else {
Queue_Replace( queue, i, func_data );
}
return 0;
}
static int Tasks_CustomAdd( LCUI_Queue *tasks, int mode, LCUI_Task *task )
{
int total, i;
LCUI_Task *tmp_task;
Queue_Lock( tasks );
total = Queue_GetTotal(tasks);
/* 如果模式是“添加新的”模式 */
if( mode == ADD_MODE_ADD_NEW ) {
Queue_Add(tasks, task);
Queue_Unlock( tasks );
return 0;
}
for (i=0; i < total; ++i) {
tmp_task = Queue_Get(tasks, i);
/* 如果指针无效，或者函数指针已有记录 */
if( !tmp_task || tmp_task->func != task->func ) {
continue;
}
/* 如果要求的是不重复模式 */
if(Check_Option(mode, ADD_MODE_NOT_REPEAT)) {
/* 如果要求是第1个参数不能重复 */
if(Check_Option(mode, AND_ARG_F)) {
/* 如果要求是第2个参数也不能重复 */
if(Check_Option(mode, AND_ARG_S)) {
/* 如果函数以及参数1和2都一样 */
if(tmp_task->arg[0] == task->arg[0]
&& tmp_task->arg[1] == task->arg[1]) {
Destroy_Task( task );
Queue_Unlock( tasks );
return -1;
}
} else {/* 否则，只是要求函数以及第1个参数不能全部重复 */
if(tmp_task->arg[0] == task->arg[0]) {
Destroy_Task( task );
Queue_Unlock( tasks );
return -1;
}
}
}/* 否则，如果只是要求是第2个参数不能重复 */
else if(Check_Option(mode, AND_ARG_S)) {
if(tmp_task->arg[1] == task->arg[1] ) {
Destroy_Task( task );
Queue_Unlock( tasks );
return -1;
}
} else {/* 否则，只是要求函数不同 */
Destroy_Task( task );
Queue_Unlock( tasks );
return -1;
}
}/* 如果要求的是替换模式 */
else if(Check_Option(mode, ADD_MODE_REPLACE)) {
/* 如果要求是第1个参数相同 */
if( Check_Option(mode, AND_ARG_F) ) {
/* 如果要求是第2个参数也相同 */
if( Check_Option(mode, AND_ARG_S) ) {
if(tmp_task->arg[0] == task->arg[0]
&& tmp_task->arg[1] == task->arg[1]
) {
break;
}
} else {/* 否则，只是要求函数以及第1个参数全部相同 */
if(tmp_task->arg[0] == task->arg[0]) {
break;
}
}
}/* 否则，如果只是要求第2个参数不能相同 */
else if(Check_Option(mode, AND_ARG_S)) {
if(tmp_task->arg[1] == task->arg[1]) {
break;
}
} else {
break;
}
}
}
if(i == total) {
Queue_Add(tasks, task);
} else {
Queue_Replace( tasks, i, task );
}
Queue_Unlock( tasks );
return 0;
}
