コード例 #1
0
ファイル: rect.c プロジェクト: fshunj/LCUI
/* 从当前占用的队列中取出一个矩形区域 */
LCUI_API LCUI_BOOL
RectQueue_GetFromCurrent( LCUI_RectQueue *queue, LCUI_Rect *rect_buff )
{
	LCUI_Rect *rect_ptr;
	LCUI_Queue *q;
	if( queue->number == 0 ) {
		q = &queue->queue[0];
	} else {
		q = &queue->queue[1];
	}
	rect_ptr = (LCUI_Rect*)Queue_Get( q, 0 );
	if( rect_ptr == NULL ) {
		Queue_Delete( q, 0 );
		return FALSE;
	}
	*rect_buff = *rect_ptr;
	Queue_Delete( q, 0 );
	return TRUE;
}
コード例 #2
0
/* 更新文本框的样式以及文本图层相关的数据 */
static void
TextBox_ExecUpdate( LCUI_Widget *widget )
{
	LCUI_TextLayer *layer;
	LCUI_TextBlock *text_ptr;
	LCUI_TextBox *textbox;
	
	textbox = Widget_GetPrivData( widget );
	/* 如果缓冲区内有文本块 */
	if( Queue_GetTotal( &textbox->text_block_buff ) > 0 ) {
		/* 获取文本块 */
		text_ptr = Queue_Get( &textbox->text_block_buff, 0 );
		if( text_ptr ) {
			//_DEBUG_MSG("text block: %p, text: %p\n", 
			//	text_ptr, text_ptr->text);
			switch( text_ptr->pos_type ) {
			    case AT_TEXT_LAST:
				/* 将此文本块追加至文本末尾 */
				__TextBox_Text_AppendW( widget, text_ptr->text );
				break;
			    case AT_CURSOR_POS:
				/* 将此文本块插入至光标当前处 */
				__TextBox_Text_Add( widget, text_ptr->text );
				break;
			    default: break;
			}
		}
		/* 删除该文本块 */
		Queue_Delete( &textbox->text_block_buff, 0 );
		/* 更新滚动条的位置 */
		TextBox_ScrollBar_UpdatePos( widget );
		/* 标记下次继续更新 */
		__Widget_Update( widget );
	}
	/* 如果文本框内没有文本,且还未显示占位符,则设置占位符并显示 */
	if( TextBox_Text_GetTotalLength( widget ) == 0
	 && !textbox->show_placeholder ) {
		layer = TextBox_GetTextLayer(widget);
		/* 备份文本框内的文本样式以及屏蔽符 */
		textbox->textstyle_bak = layer->default_data;
		textbox->password_char_bak = layer->password_char.char_code;
		/* 占位符不能被屏蔽,所以设置屏蔽符为0 */
		TextLayer_Text_SetPasswordChar( layer, 0 );
		/* 文本框内显示占位符 */
		TextLayer_TextW( layer, textbox->placeholder.string );
		/* 设置占位符的样式 */
		TextLayer_Text_SetDefaultStyle( layer, textbox->placeholder_style );
		textbox->show_placeholder = TRUE;
	}
	TextBox_ExecUpdateStyle( widget ); /* 更新文本框的样式 */
	Widget_ExecUpdate( TextBox_GetLabel( widget ) ); /* 更新文本图层的内容 */
	TextBox_ScrollBar_UpdateSize( widget ); /* 更新滚动条的长度 */
	TextBox_Cursor_Update( widget ); /* 更新文本框内的光标 */
}
コード例 #3
0
TextLayer_SetRowEnd( LCUI_TextLayer *layer, uint_t row, uint_t start_cols )
/* 为指定行设定结束点,结束点及后面的数据将被删除,但不记录残余文本位图区域 */
{
	uint_t total, i;
	Text_RowData *row_data; 
	
	row_data = Queue_Get( &layer->rows_data, row );
	total = Queue_GetTotal( &row_data->string );
	/* 移除多余的数据 */
	for(i=start_cols; i<total; ++i) {
		Queue_Delete( &row_data->string, start_cols ); 
	}
}
コード例 #4
0
ファイル: main.c プロジェクト: yydaor/LCUI
static void LCUI_DestroyAllApps(void)
{
	LCUI_App *app; 
	int i, total;

	Queue_Lock( &LCUI_Sys.app_list );
	total = Queue_GetTotal(&LCUI_Sys.app_list);
	for (i = 0; i < total; ++i) {
		app = Queue_Get(&LCUI_Sys.app_list, 0);
		if(app == NULL) {
			continue;
		}
		Queue_Delete (&LCUI_Sys.app_list, 0); 
	}
	Queue_Unlock( &LCUI_Sys.app_list );
	Queue_Destroy( &LCUI_Sys.app_list );
}
コード例 #5
0
ファイル: widget_event.c プロジェクト: FrankHB/LCUI
/** 移除指定部件的记录,使之不再响应状态变化 */
LCUI_API void WidgetRecord_Delete( LCUI_Widget *widget )
{
	int n;
	WidgetRecordItem *item;

	Queue_Lock( &widget_proc_record );
	n = Queue_GetTotal( &widget_proc_record );
	for(; n>=0; --n) {
		item = (WidgetRecordItem*)
		Queue_Get( &widget_proc_record, n );
		if( item && item->widget == widget ) {
			Queue_Delete( &widget_proc_record, n );
			break;
		}
	}
	Queue_Unlock( &widget_proc_record );
}
コード例 #6
0
static int
TextLayer_Text_DeleteChar( 
		LCUI_TextLayer *layer, 
		LCUI_CharData *char_ptr, 
		int left_or_right )
/* 
 * 功能:将字符数据从源文本中移除
 * 参数:
 * layer         操作对象
 * char_ptr      指向所要删除的字符数据的指针
 * left_or_right 指定在源文本中遍历的方向,值为0时是向左遍历,其它值则像右遍历
 *  */
{
	int n;
	n = TextLayer_GetCharPos( layer, char_ptr, left_or_right );
	/* 将该字从源文本中移除 */
	Queue_Delete( &layer->text_source_data, n );
	return 0;
}
コード例 #7
0
ファイル: game_msg.c プロジェクト: fztfztfzt/PunchAndKick
/* 从消息队列中取出一个消息 */
int Game_GetMsg( GameMsg *msg_buff )
{
	GameMsg *p_msg;

	Game_RecvMsg();
	while( Queue_GetTotal(&game_msg_queue)<=0 ) {
		LCUISleeper_StartSleep( &msg_sleeper, 1000 );
	}
	Queue_Lock( &game_msg_queue );
	p_msg = (GameMsg*)Queue_Get( &game_msg_queue, 0 );
	if( p_msg == NULL ) {
		Queue_Unlock( &game_msg_queue );
		return -1;
	}
	*msg_buff = *p_msg;
	Queue_Delete( &game_msg_queue, 0 );
	Queue_Unlock( &game_msg_queue );
	return 0;
}
コード例 #8
0
ファイル: textstyle.c プロジェクト: gateslu/LCUI
/** 将指定标签的样式数据从队列中删除,只删除队列尾部第一个匹配的标签 */
static void StyleTag_Delete( LCUI_Queue *tags, StyleTag_ID tag )
{
	int i, total;
	StyleTag_Data *p; 
	 
	total = Queue_GetTotal( tags );
	DEBUG_MSG("delete start, total tag: %d\n", Queue_GetTotal( tags ));
	if(total <= 0) {
		return;
	}
	for(i=total-1; i>=0; --i) {
		p = Queue_Get( tags, i );
		if( p->tag == tag ) {
			Queue_Delete( tags, i );
			break;
		}
	} 
	DEBUG_MSG("delete end, total tag: %d\n", Queue_GetTotal( tags ));
}
コード例 #9
0
ファイル: LCUI_Work.c プロジェクト: soar-penguin/LCUI
int 
Run_Task( LCUI_App *app )
/* 功能:执行任务 */
{ 
	static LCUI_Task *task;
	task = (LCUI_Task*)Queue_Get( &app->task_queue, 0 );
	//clock_t start = clock();
	//printf("run task %p\n", task->func);
	/* 调用函数指针指向的函数,并传递参数 */
	task->func( task->arg[0], task->arg[1] );
	/* 若需要在调用回调函数后销毁参数 */
	if( task->destroy_arg[0] ) {
		free( task->arg[0] );
	}
	if( task->destroy_arg[1] ) {
		free( task->arg[1] );
	}
	//printf("task %p use time: %ldus\n", task->func, clock()-start);
	return Queue_Delete(&app->task_queue, 0);
}
コード例 #10
0
ファイル: widget_event.c プロジェクト: FrankHB/LCUI
/** 清理部件列表中需要移除的部件,并将部件状态设置为NORMAL */
static void WidgetRecord_Clear( void )
{
	int i, n;
	WidgetRecordItem *item;

	Queue_Lock( &widget_proc_record );
	n = Queue_GetTotal( &widget_proc_record );
	for(i=0; i<n; ++i) {
		item = (WidgetRecordItem*)
		Queue_Get( &widget_proc_record, i );
		if( !item->need_delete ) {
			continue;
		}
		Widget_SetState( item->widget, WIDGET_STATE_NORMAL );
		Queue_Delete( &widget_proc_record, i );
		n = Queue_GetTotal( &widget_proc_record );
		--i;
	}
	Queue_Unlock( &widget_proc_record );
}
コード例 #11
0
ファイル: LCUI_TextBox.c プロジェクト: soar-penguin/LCUI
static void
Exec_TextBox_Update( LCUI_Widget *widget )
/* 更新文本框的文本图层 */
{
	LCUI_TextBlock *text_ptr;
	LCUI_TextBox *textbox;
	
	textbox = Get_Widget_PrivData( widget );
	/* 如果缓冲区内有文本块 */
	if( Queue_Get_Total( &textbox->text_block_buff ) > 0 ) {
		/* 获取文本块 */
		text_ptr = Queue_Get( &textbox->text_block_buff, 0 );
		if( text_ptr ) {
			//_DEBUG_MSG("text block: %p, text: %p\n", 
			//	text_ptr, text_ptr->text);
			switch( text_ptr->pos_type ) {
			    case AT_TEXT_LAST:
				/* 将此文本块追加至文本末尾 */
				__TextBox_Text_Append( widget, text_ptr->text );
				break;
			    case AT_CURSOR_POS:
				/* 将此文本块插入至光标当前处 */
				__TextBox_Text_Add( widget, text_ptr->text );
				break;
			    default: break;
			}
		}
		/* 删除该文本块 */
		Queue_Delete( &textbox->text_block_buff, 0 );
		/* 更新滚动条的位置 */
		TextBox_ScrollBar_Update_Pos( widget );
		/* 标记下次继续更新 */
		__Update_Widget( widget );
	}
	/* 更新文本图层的内容 */
	Exec_Update_Widget( TextBox_Get_Label( widget ) );
	/* 更新滚动条的长度 */
	TextBox_ScrollBar_Update_Size( widget );
	/* 更新文本框内的光标 */
	TextBox_Cursor_Update( widget );
}
コード例 #12
0
ファイル: text_layer.c プロジェクト: dwdcth/LCUI
static void 
TextLayer_TagStyle_Delete( LCUI_TextLayer *layer, enum_tag_id tag)
/* 将指定标签的样式数据从队列中删除,只删除队列尾部第一个匹配的标签 */
{
	int i, total;
	tag_style_data *p; 
	 
	total = Queue_Get_Total( &layer->tag_buff );
	DEBUG_MSG("delete start, total tag: %d\n", Queue_Get_Total( &layer->tag_buff ));
	if(total <= 0) {
		return;
	}
	for(i=total-1; i>=0; --i) {
		p = Queue_Get( &layer->tag_buff, i );
		if( p->tag == tag ) {
			Queue_Delete( &layer->tag_buff, i );
			break;
		}
	} 
	DEBUG_MSG("delete end, total tag: %d\n", Queue_Get_Total( &layer->tag_buff ));
}
コード例 #13
0
ファイル: widget_msg.c プロジェクト: fshunj/LCUI
LCUI_API void WidgetMsg_Proc( LCUI_Widget *widget )
{
	int i,n;
	WidgetMsgData *data_ptr;
	LCUI_Widget *child;
	LCUI_Queue *msg_buff, *child_list;
	
	if( widget == NULL ) {
		widget = RootWidget_GetSelf();
	}
	msg_buff = Widget_GetMsgBuff( widget );
	child_list = Widget_GetChildList( widget );
	
	Queue_Lock( msg_buff );
	n = Queue_GetTotal( msg_buff );
	for(i=0; i<n; ++i) {
		DEBUG_MSG("[%d/%d]get msg\n", i, n);
		data_ptr = (WidgetMsgData*)Queue_Get( msg_buff, i );
		DEBUG_MSG("[%d/%d]dispatch msg\n", i, n);
		if( WidgetMsg_Dispatch( widget, data_ptr ) ) {
			DEBUG_MSG("[%d/%d]delete msg\n", i, n);
			Queue_Delete( msg_buff, i );
			n = Queue_GetTotal( msg_buff );
			--i;
		}
		DEBUG_MSG("[%d/%d]skip msg\n", i, n);
	}
	Queue_Unlock( msg_buff );
	n = Queue_GetTotal( child_list );
	/* 从尾到首,递归处理子部件的更新 */
	while(n--) {
		child = (LCUI_Widget*)Queue_Get( child_list, n );
		if( child ) {
			DEBUG_MSG("proc child msg\n");
			WidgetMsg_Proc( child );
		}
	}
}
コード例 #14
0
ファイル: LCUI_PictureBox.c プロジェクト: dwdcth/LCUI
void Set_PictureBox_Image_From_Graph(LCUI_Widget *widget, LCUI_Graph *image)
/* 功能:添加一个图片数据至图片盒子 */
{
    int i;
    float scale_x,scale_y;
    LCUI_Graph *graph = image;
    LCUI_PictureBox *pic_box = (LCUI_PictureBox*)
                               Get_Widget_PrivData(widget);
    for(i = 0; i < 2; ++i) {
        /* 如果image有效 */
        if(Graph_Valid(graph)) {
            /* 图片更换了,就释放缓存图形 */
            Graph_Free(&pic_box->buff_graph);
            pic_box->image = graph;
            /* 读取的范区域为整个图片区域 */
            pic_box->read_box.x = 0;
            pic_box->read_box.y = 0;
            pic_box->read_box.width = graph->width;
            pic_box->read_box.height = graph->height;
            pic_box->read_box.center_x = 0.5;
            pic_box->read_box.center_y = 0.5;
            pic_box->scale = 1.0;

            //printf("Set_PictureBox_Image_From_Graph(): img, w: %d, h: %d\n", graph->width, graph->height);
            //printf("Set_PictureBox_Image_From_Graph(): pb: w: %d, h: %d\n", widget->size.w, widget->size.h);
            //printf("Set_PictureBox_Image_From_Graph(): size mode: %d\n", pic_box->size_mode);
            switch(pic_box->size_mode) {
            case SIZE_MODE_BLOCK_ZOOM:
            case SIZE_MODE_ZOOM:
                //printf("Set_PictureBox_Image_From_Graph(): widget: w: %d, h: %d\n", widget->size.w, widget->size.h);
                if(widget->size.w <= 0 || widget->size.h <= 0) {
                    //printf("Set_PictureBox_Image_From_Graph(): break\n");
                    break;
                }
                scale_x = (float)widget->size.w / pic_box->image->width;
                scale_y = (float)widget->size.h / pic_box->image->height;
                if(scale_x < scale_y) pic_box->scale = scale_x;
                else pic_box->scale = scale_y;
                //printf("Set_PictureBox_Image_From_Graph(): scale: %.4f, x: %.4f, y: %.4f\n",
                //pic_box->scale, scale_x, scale_y);
                Zoom_PictureBox_View_Area(widget, pic_box->scale);
                //printf("Set_PictureBox_Image_From_Graph(): read box: %d,%d,%d,%d\n",
                //pic_box->read_box.x, pic_box->read_box.y,
                //pic_box->read_box.width, pic_box->read_box.height);
                break;
            /* 正常模式 */
            case SIZE_MODE_NORMAL:
                break;
            /* 拉伸模式 */
            case SIZE_MODE_STRETCH:
                break;
            /* 平铺模式 */
            case SIZE_MODE_TILE:
                break;
            case SIZE_MODE_CENTER:
                /* 判断图像的尺寸是否超出图片盒子的尺寸 */
                if(pic_box->image->width >= widget->size.w) {
                    pic_box->read_box.x = (pic_box->image->width - widget->size.w)/2.0;
                    pic_box->read_box.width = widget->size.w;
                }
                if(pic_box->image->height >= widget->size.h) {
                    pic_box->read_box.y = (pic_box->image->height - widget->size.h)/2.0;
                    pic_box->read_box.height = widget->size.h;
                }
                break;
            default :
                break;
            }
            break;
        } else if(pic_box->image_status == IMAGE_STATUS_LOADING) {
            /* 使用对应的图片 */
            if(Graph_Valid(&pic_box->initial_image)) {
                graph = &pic_box->initial_image;
            } else {
                return;
            }
        }
        else { /* 使用对应的图片 */
            if(Graph_Valid(&pic_box->error_image)) {
                graph = &pic_box->error_image;
                pic_box->image_status = IMAGE_STATUS_FAIL;
            } else {
                return;
            }
        }
    }
    /* 如果记录中有该部件,那判断该部件使用的图像是否为同一个,不一样就释放之前的 */
    graph_data *data;
    i = find_widget_data(widget);
    if(i >= 0) {
        data = (graph_data*)Queue_Get(&picbox_graph_mem, i);
        if(data->image != image) {
            Queue_Delete(&picbox_graph_mem, i);
        }
    }
    Draw_Widget(widget);
}
コード例 #15
0
ファイル: text_layer.c プロジェクト: dwdcth/LCUI
void 
TextLayer_Draw( LCUI_Widget *widget, LCUI_TextLayer *layer, int mode )
/* 绘制文本图层 */
{
	LCUI_Rect area;
	LCUI_Pos pos;
	int i, j, n, rows, size;
	LCUI_RGB color;
	LCUI_Graph slot;
	LCUI_CharData *p_data;
	Text_RowData *p_row;
	
	Graph_Init( &slot );
	
	n = Queue_Get_Total( &layer->clear_area ); 
	for(i=0; i<n; ++i) { 
		RectQueue_Get( &area, 0 , &layer->clear_area ); 
		Queue_Delete( &layer->clear_area, 0 ); 
		Quote_Graph( &slot, &widget->graph, area );
		/* 将该区域的alpha通道填充为0 */
		Graph_Fill_Alpha( &slot, 0 ); 
		Add_Widget_Refresh_Area( widget, area ); 
	} 
	
	/* 开始粘贴文本位图 */
	rows = Queue_Get_Total( &layer->rows_data ); 
	for(pos.y=0,i=0; i<rows; ++i) {
		p_row = Queue_Get( &layer->rows_data, i );
		n = Queue_Get_Total( &p_row->string ); 
		pos.x = 0;
		//
		//if( p_row->pos.y != pos.y ) { 
		//	RectQueue_Add( &layer->clear_area, Rect(pos.x, pos.y, 
		//		p_row->max_size.w, p_row->max_size.h) );
		//	p_row->pos.y = pos.y;
		//} 
		for(j=0; j<n; ++j) {
			p_data = Queue_Get( &p_row->string, j ); 
			if( p_data->data != NULL ) {
				//if( p_data->data->pixel_size > 0 ) {
					size = p_data->data->pixel_size;
				//} else { 
				//	size = layer->default_data.pixel_size;
				//}
				size += 2;
				
				//if( p_data->data->_fore_color ) {
					color = p_data->data->fore_color;
				//} else {
				//	color = layer->default_data.fore_color;
				//}
			} else {
				size = layer->default_data.pixel_size + 2; 
				color = layer->default_data.fore_color;
			}
			pos.x += p_data->bitmap.left;
			if( p_data->need_update ) {
				p_data->need_update = FALSE; 
				area = Rect(pos.x, pos.y, size, size);
				/* 贴上字体位图 */
				FontBMP_Mix( &widget->graph, Pos( pos.x, 
					pos.y + p_row->max_size.h-1 - p_data->bitmap.top),
					&p_data->bitmap, color, mode );
				Add_Widget_Refresh_Area( widget, area );  
			}
			pos.x += p_data->bitmap.width;
		}
		pos.y += p_row->max_size.h;
	}
}
コード例 #16
0
ファイル: rect.c プロジェクト: fshunj/LCUI
/* 将矩形数据追加至队列 */
static int
RectQueue_Add( LCUI_Queue* queue, LCUI_Rect rect )
{ 
	int i, flag = 0;
	LCUI_Rect *rect_ptr, *cur_rect_ptr;
	LCUI_Queue rect_buff;
	
	if( rect.width <= 0 || rect.height <= 0 ) {
		return -1;
	}
	DEBUG_MSG("add new rect: %d,%d,%d,%d, current total: %d\n",
	 rect.x, rect.y, rect.width, rect.height, queue->total_num);
	Queue_Init( &rect_buff, sizeof(LCUI_Rect), NULL );
	
	for (i=0; i<queue->total_num; ++i) {
		cur_rect_ptr = (LCUI_Rect*)Queue_Get( queue, i );
		if( !cur_rect_ptr ) {
			break;
		}
		DEBUG_MSG("[%d] rect: %d,%d,%d,%d\n", i, 
		 cur_rect_ptr->x, cur_rect_ptr->y,
		 cur_rect_ptr->width, cur_rect_ptr->height);
		/* 如果矩形无效,或者被新增的矩形区域包含,则删除 */
		if ( cur_rect_ptr->width <= 0 || cur_rect_ptr->height <= 0
		 || LCUIRect_IncludeRect( rect, *cur_rect_ptr) ) {
			Queue_Delete ( queue, i );
			continue;
		}

		/* 如果与现有的矩形相同,或被现有的矩形包含 */
		if( LCUIRect_Equal( rect, *cur_rect_ptr)
		 || LCUIRect_IncludeRect( *cur_rect_ptr, rect ) ) {
			flag = 1;
			break;
		}
		
		/* 如果新增的矩形与队列中的矩形不重叠 */ 
		if( !LCUIRect_Overlay(rect, *cur_rect_ptr) ) {
			continue;
		}
		continue; // 暂时不对相交的矩形进行分割
		DEBUG_MSG("[%d] rect overlay, start cut\n", i);
		/* 根据当前区域,分割新区域 */
		LCUIRect_Cut( *cur_rect_ptr, rect, &rect_buff );
		for( i=0; i<rect_buff.total_num; ++i ) {
			rect_ptr = (LCUI_Rect*)Queue_Get( &rect_buff, i );
			if( !rect_ptr ) {
				break;
			}
			DEBUG_MSG("[%d] add child rect: %d,%d,%d,%d\n", i, 
				 rect_ptr->x, rect_ptr->y,
				 rect_ptr->width, rect_ptr->height);
			RectQueue_Add( queue, *rect_ptr );
		}
		flag = 1;
		break;
	}
	
	/* 销毁队列 */
	Queue_Destroy( &rect_buff );
	if ( flag == 0 ) {
		return Queue_Add( queue, &rect );
	}
	return -1;
}
コード例 #17
0
TextLayer_Draw( LCUI_Widget *widget, LCUI_TextLayer *layer, int mode )
/* 将文本图层绘制到目标部件的图层上 */
{
	LCUI_Rect area;
	LCUI_Pos pos, mix_pos;
	LCUI_BOOL draw_all = FALSE, redraw_row;
	int i, j, n, rows, size;
	LCUI_RGB color;
	LCUI_Graph slot, *graph;
	LCUI_CharData *p_data;
	Text_RowData *p_row;
	
	//clock_t start;
	//start = clock();
	//_DEBUG_MSG("enter\n");
	
	graph = Widget_GetSelfGraph( widget );
	/* 如果文本缓存区内有数据 */
	if( layer->need_proc_buff ) {
		__TextLayer_Text( layer );
		layer->need_proc_buff = FALSE;
	}
	/* 如果需要滚动图层 */
	if( layer->need_scroll_layer ) {
		layer->need_scroll_layer = FALSE;
		//_DEBUG_MSG("layer->need_scroll_layer\n");
		/* 根据之前记录的偏移坐标,刷新文本图层 */
		__TextLayer_OldArea_Erase( layer, Widget_GetSelfGraph( widget ) );
		draw_all = TRUE;
	}
	
	//_DEBUG_MSG("1, use time: %ld\n", clock() - start );
	//start = clock();
	
	Graph_Init( &slot );
	/* 先处理需要清空的区域 */
	n = Queue_GetTotal( &layer->clear_area ); 
	for(i=0; i<n; ++i) { 
		RectQueue_Get( &area, 0 , &layer->clear_area ); 
		area.x += layer->offset_pos.x;
		area.y += layer->offset_pos.y;
		Queue_Delete( &layer->clear_area, 0 );
		Graph_Quote( &slot, graph, area );
		/* 将该区域的alpha通道填充为0 */
		Graph_FillAlpha( &slot, 0 );
		Widget_InvalidArea( widget, area ); 
		//printf("refresh area: %d,%d,%d,%d\n",
		//area.x, area.y, area.width, area.height);
	}
	//_DEBUG_MSG("2, use time: %ld\n", clock() - start );
	//start = clock();
	/* 开始绘制文本位图至目标图层上 */
	rows = Queue_GetTotal( &layer->rows_data ); 
	for(pos.y=layer->offset_pos.y,i=0; i<rows; ++i) {
		redraw_row = FALSE;
		p_row = Queue_Get( &layer->rows_data, i );
		if( !p_row ) {
			continue;
		}
		n = Queue_GetTotal( &p_row->string );
		/* 如果当前字的位图的Y轴跨距不在有效绘制区域内 */
		if( pos.y + p_row->max_size.h <= 0 ) {
			pos.y += p_row->max_size.h;
			continue;
		}
		for(pos.x=layer->offset_pos.x,j=0; j<n; ++j) {
			/* 如果设置了屏蔽符 */
			p_data = Queue_Get( &p_row->string, j ); 
			if( !p_data ) {
				continue;
			}
			
			if( layer->password_char.char_code > 0 ) {
				layer->password_char.need_update = p_data->need_update;
				p_data = &layer->password_char;
			}
			/* 如果当前字的位图的X轴跨距不在有效绘制区域内 */
			if( pos.x + p_data->bitmap->advance.x <= 0) {
				pos.x += p_data->bitmap->advance.x;
				continue;
			}
			/* 获取该字体位图的大致尺寸 */
			if( p_data->data ) {
				size = p_data->data->pixel_size;
				size += 2;
				color = p_data->data->fore_color;
			} else {
				size = layer->default_data.pixel_size + 2; 
				color = layer->default_data.fore_color;
			}
			/* 如果字体位图已标记更新,则绘制它 */
			if( p_data->need_update || draw_all ) {
				p_data->need_update = FALSE;
				if( !redraw_row ) {
					area.x = pos.x;
					area.height = p_row->max_size.h;
					redraw_row = TRUE;
				}
				mix_pos.x = pos.x + p_data->bitmap->left;
				mix_pos.y = pos.y + p_row->max_size.h-1;
				mix_pos.y -= p_data->bitmap->top;
				/* 贴上字体位图 */
				FontBMP_Mix( graph, mix_pos,
					p_data->bitmap, color, mode );
			}
			pos.x += p_data->bitmap->advance.x;
			if( pos.x > widget->size.w ) {
				break;
			}
		}
		if(redraw_row) {
			area.y = pos.y;
			area.width = pos.x - area.x;
			//_DEBUG_MSG("area:%d,%d,%d,%d\n", 
			//area.x, area.y, area.width, area.height);
			Widget_InvalidArea( widget, area );
		}
		pos.y += p_row->max_size.h;
		if( pos.y > widget->size.h ) {
			break;
		}
	}
	//_DEBUG_MSG("3, use time: %ld\n", clock() - start );
	//_DEBUG_MSG("quit\n");
}
コード例 #18
0
static int 
_TextLayer_Text_Delete ( LCUI_TextLayer *layer, LCUI_Pos start_pos, int len )
/* 以start_pos为起点,删除n个文字 */
{
	LCUI_BOOL refresh = TRUE;
	LCUI_CharData *char_ptr;
	LCUI_Pos tmp_pos, pixel_pos;
	int left_or_right, rows, cols;
	Text_RowData *row_ptr, *tmp_row;
	
	if( start_pos.x < 0 ) {
		len += start_pos.x;
		start_pos.x = 0;
	}
	if( start_pos.y < 0 ) {
		start_pos.y = 0;
	}
	if( len <= 0 ) {
		return -1;
	}
	/* 确定起点位置的XY轴坐标 */
	pixel_pos = TextLayer_Char_GetPixelPos( layer, start_pos );
	
	rows = Queue_GetTotal( &layer->rows_data );
	row_ptr = Queue_Get( &layer->rows_data, start_pos.y );
	if( !row_ptr ) {
		return -1;
	}
	cols = Queue_GetTotal( &row_ptr->string );
	
	/* 根据光标所在位置,确定遍历方向 */
	if( layer->current_des_pos.y > start_pos.y 
	 || (layer->current_des_pos.y == start_pos.y 
	 && layer->current_des_pos.x > start_pos.x)) {
		left_or_right = 0;
	}
	else {
		left_or_right = 1;
	}
	
	/* 如果需删除的字符只在当前行 */
	if( start_pos.x + len <= cols ) {
		/* 标记后面的文字位图需要刷新 */
		TextLayer_CharLater_Refresh( layer, start_pos );
	}
	for( ; start_pos.x<=cols && len>0; --len ) {
		/* 如果到了行尾 */
		if( start_pos.x == cols ) {
			/* 如果当前行是最后一行 */
			if( start_pos.y >= rows-1 ) {
				break;
			}
			if( refresh ) {
				tmp_pos.x = 0;
				tmp_pos.y=start_pos.y+1;
				/* 刷新该行后面所有行的字符 */
				for( ; tmp_pos.y<rows; ++tmp_pos.y ) {
					TextLayer_CharLater_Refresh( layer, tmp_pos );
				}
				refresh = FALSE;
			}
			
			/* 将当前行行尾的换行符'\n'从源文本中移除 */
			TextLayer_Text_DeleteChar( layer, row_ptr->last_char, left_or_right );
			/* 获取指向下一行文本的指针 */
			tmp_row = Queue_Get( &layer->rows_data, start_pos.y+1 );
			/* 将下一行的文本拼接至当前行行尾 */
			Queue_Cat( &row_ptr->string, &tmp_row->string );
			/* 将下一行的行尾字符数据转移至当前行 */
			row_ptr->last_char = tmp_row->last_char;
			/* 销毁下一行的文本 */
			Queue_Destroy( &tmp_row->string ); 
			Queue_Delete( &layer->rows_data, start_pos.y+1 );
			/* 更新当前行的总字符数 */
			cols = Queue_GetTotal( &row_ptr->string );
			/* 更新总行数 */
			rows = Queue_GetTotal( &layer->rows_data );
			/* 更新当前行的尺寸 */
			TextLayer_Update_RowSize( layer, start_pos.y );
			continue;
		}
		char_ptr = Queue_Get( &row_ptr->string, start_pos.x );
		if( !char_ptr ) {
			continue;
		}
		TextLayer_Clear( layer, pixel_pos, row_ptr->max_size.h, char_ptr );
		pixel_pos.x += char_ptr->bitmap->advance.x;
		/* 将该字从源文本中移除 */
		TextLayer_Text_DeleteChar( layer, char_ptr, left_or_right );
		/* 该字在这行的字体位图也需要删除 */
		cols = Queue_GetTotal( &row_ptr->string );
		Queue_DeletePointer( &row_ptr->string, start_pos.x );
		cols = Queue_GetTotal( &row_ptr->string );
		char_ptr = Queue_Get( &row_ptr->string, start_pos.x );
		cols = Queue_GetTotal( &row_ptr->string );
	}
	/* 更新当前行的尺寸 */
	TextLayer_Update_RowSize( layer, start_pos.y );
	return 0;
}
コード例 #19
0
ファイル: text_layer.c プロジェクト: soar-penguin/LCUI
void 
TextLayer_Draw( LCUI_Widget *widget, LCUI_TextLayer *layer, int mode )
/* 将文本图层绘制到目标部件的图层上 */
{
	LCUI_Rect area;
	LCUI_Pos pos;
	BOOL draw_all = FALSE;
	int i, j, n, rows, size;
	LCUI_RGB color;
	LCUI_Graph slot;
	LCUI_CharData *p_data;
	Text_RowData *p_row;
	
	//clock_t start;
	//start = clock();
	//printf("TextLayer_Draw(): enter\n");
	/* 如果文本缓存区内有数据 */
	if( layer->need_proc_buff ) {
		__TextLayer_Text( layer );
		layer->need_proc_buff = FALSE;
	}
	/* 如果需要滚动图层 */
	if( layer->need_scroll_layer ) {
		/* 根据之前记录的偏移坐标,刷新文本图层 */
		__TextLayer_OldArea_Erase( widget, layer );
		draw_all = TRUE;
		layer->need_scroll_layer = FALSE;
	}
	
	//nobuff_printf("1, use time: %ld\n", clock() - start );
	//start = clock();
	
	Graph_Init( &slot );
	/* 先处理需要清空的区域 */
	n = Queue_Get_Total( &layer->clear_area ); 
	for(i=0; i<n; ++i) { 
		RectQueue_Get( &area, 0 , &layer->clear_area ); 
		area.x += layer->offset_pos.x;
		area.y += layer->offset_pos.y;
		Queue_Delete( &layer->clear_area, 0 );
		Quote_Graph( &slot, &widget->graph, area );
		/* 将该区域的alpha通道填充为0 */
		Graph_Fill_Alpha( &slot, 0 );
		Add_Widget_Refresh_Area( widget, area ); 
		//printf("refresh area: %d,%d,%d,%d\n",
		//area.x, area.y, area.width, area.height);
	}
	//nobuff_printf("2, use time: %ld\n", clock() - start );
	//start = clock();
	/* 开始绘制文本位图至目标图层上 */
	rows = Queue_Get_Total( &layer->rows_data ); 
	for(pos.y=layer->offset_pos.y,i=0; i<rows; ++i) {
		p_row = Queue_Get( &layer->rows_data, i );
		if( !p_row ) {
			continue;
		}
		n = Queue_Get_Total( &p_row->string );
		/* 如果当前字的位图的Y轴跨距不在有效绘制区域内 */
		if( pos.y + p_row->max_size.h <= 0 ) {
			pos.y += p_row->max_size.h;
			continue;
		}
		for(pos.x=layer->offset_pos.x,j=0; j<n; ++j) {
			/* 如果设置了屏蔽符 */
			p_data = Queue_Get( &p_row->string, j ); 
			if( !p_data ) {
				continue;
			}
			
			if( layer->password_char.char_code > 0 ) {
				layer->password_char.need_update = p_data->need_update;
				p_data = &layer->password_char;
			}
			/* 如果当前字的位图的X轴跨距不在有效绘制区域内 */
			if( pos.x + p_data->bitmap.advance.x <= 0) {
				pos.x += p_data->bitmap.advance.x;
				continue;
			}
			/* 获取该字体位图的大致尺寸 */
			if( p_data->data ) {
				size = p_data->data->pixel_size;
				size += 2;
				color = p_data->data->fore_color;
			} else {
				size = layer->default_data.pixel_size + 2; 
				color = layer->default_data.fore_color;
			}
			/* 如果字体位图已标记更新,则绘制它 */
			if( p_data->need_update || draw_all ) { 
			//nobuff_printf("get, pos: %d, char_ptr: %p, char: %c, draw\n", 
			//	i, p_data, p_data->char_code ); 
				p_data->need_update = FALSE;
				/* 计算区域范围 */
				area.x = pos.x + p_data->bitmap.left;
				area.y = pos.y + p_row->max_size.h-1;
				area.y -= p_data->bitmap.top;
				area.height = p_data->bitmap.rows;
				area.width = p_data->bitmap.width;
				/* 贴上字体位图 */
				FontBMP_Mix( &widget->graph, Pos(area.x, area.y),
					&p_data->bitmap, color, mode );
				/* 记录该区域,以刷新显示到屏幕上 */
				Add_Widget_Refresh_Area( widget, area );
			}
			pos.x += p_data->bitmap.advance.x;
			if( pos.x > widget->size.w ) {
				break;
			}
		}
		pos.y += p_row->max_size.h;
		if( pos.y > widget->size.h ) {
			break;
		}
	}
	//nobuff_printf("3, use time: %ld\n", clock() - start );
	//printf("TextLayer_Draw(): quit\n");
}