#include "cc_config.h"
#include "cc_type.h"
#include "cc_def.h"
#include "cc_private.h"

static tDCC_DefWin p_dfw[8];

static struct {
	BOOL flash_fg;
	int user_posx;
	int user_posy;
	UINT8 win_list[8]; /* °¡Àå prio°¡ ³ôÀº winºÎÅÍ ³·Àº ¼øÀ¸·Î Á¤·ÄµÊ */
	UINT8 num_win_list;
	
} p_win_info;

#define INFO(i) p_win_info.i


#if 0
__Basic_Misc_Func__()
#endif


static UINT8 p_get_color(UINT8 c, UINT8 o)
{
	UINT8 ret=0;

	if(o==eDCC_O_FLASH) {
#if ENABLE_FLASH
		o=eDCC_O_SOLID;
		if(INFO(flash_fg)==0) c=eDCC_C_NONE;
#else
		ret = c;
#endif
	}	

	if(o==eDCC_O_SOLID)
		ret = c;
	else if(o==eDCC_O_TRANSLUCENT)
		ret = c | 0x8;
	else if(o==eDCC_O_TRANSPARENT)
		ret = eDCC_C_TRANSPARENT;
	
	return ret;
}



#if 0
__Basic_Win_Func__()
#endif


static BOOL p_is_dot_in_rect(int x, int y, tDCC_RECT *pr)
{
	return ((x>=pr->x && x<=pr->x+pr->w) && (y>=pr->y && y<=pr->y+pr->h));
}


static BOOL p_is_rect_overlap(tDCC_RECT *pr1, tDCC_RECT *pr2)
{
	if(p_is_dot_in_rect(pr2->x, pr2->y, pr1)) return TRUE;
	if(p_is_dot_in_rect(pr2->x+pr2->w, pr2->y, pr1)) return TRUE;
	if(p_is_dot_in_rect(pr2->x, pr2->y+pr2->h, pr1)) return TRUE;
	if(p_is_dot_in_rect(pr2->x+pr2->w, pr2->y+pr2->h, pr1)) return TRUE;
	
	if(p_is_dot_in_rect(pr1->x, pr1->y, pr2)) return TRUE;
	if(p_is_dot_in_rect(pr1->x+pr1->w, pr1->y, pr2)) return TRUE;
	if(p_is_dot_in_rect(pr1->x, pr1->y+pr1->h, pr2)) return TRUE;
	if(p_is_dot_in_rect(pr1->x+pr1->w, pr1->y+pr1->h, pr2)) return TRUE;
	
	return FALSE;
}


static BOOL p_is_win_overlap(tDCC_DefWin *pwin1, tDCC_DefWin *pwin2)
{
	if(!pwin1->bcreated || !pwin1->v) return FALSE;
	if(!pwin2->bcreated || !pwin2->v) return FALSE;

	return p_is_rect_overlap(&pwin1->win_r, &pwin2->win_r);
}


static void p_update_overlap_win()
{
	//overlap
	int i, j;
	int temp;
	
	for(i=0, INFO(num_win_list)=0; i<8; i++) {
		if(!p_dfw[i].bcreated || !p_dfw[i].v) continue;
		INFO(win_list)[INFO(num_win_list)++]=(UINT8)i;
	}
	
	/* 1. win_list¿¡ Á¤·Ä */
	for(i=0; i<INFO(num_win_list)-1; i++) {
		for(j=0; j<INFO(num_win_list)-i-1; j++) {
			if((p_dfw[j].p > p_dfw[j+1].p) || 
				((p_dfw[j].p == p_dfw[j+1].p) && (p_dfw[j].id_draw > p_dfw[j+1].id_draw))) {
				/* swap */
				temp=INFO(win_list)[j];
				INFO(win_list)[j]=INFO(win_list)[j+1];
				INFO(win_list)[j+1]=temp;
			}
		}
	}
	
	/* Á¤·ÄµÈ win_list¸¦ º¸°í °¢°¢ÀÇ dfw¿¡ overlap winÀ» ¾÷µ¥ÀÌÆ®ÇÔ */
	for(i=INFO(num_win_list)-1; i>0; i--) {
		int overlap_idx=0;
		
		for(j=i-1; j>=0; j--) {
			if(!p_is_win_overlap(&p_dfw[INFO(win_list)[i]], &p_dfw[INFO(win_list)[j]])) continue;
			
			p_dfw[INFO(win_list)[i]].overlap_win[overlap_idx++]=INFO(win_list)[j];
		}
		p_dfw[INFO(win_list)[i]].num_overlap_win=overlap_idx;
	}

}


static BOOL p_get_win_rect(tDCC_DefWin *pwin, BOOL is_test)
{
	int i;
	int new_ah, new_av;
	tDCC_RECT temp, *r=&temp;
	int highest;
	BOOL is_changed=FALSE;
	int font_mw, font_mh;
	
	if(!pwin->bcreated) return FALSE;
	
	memset(r, 0, sizeof(*r));

	if(pwin->cl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
		font_mw=DCCGrp_GetMaxFontWidth(pwin->pen_attr.s, USE_KOR_CC?TRUE:FALSE);
	else
		font_mw=DCCGrp_GetMaxFontWidth(pwin->rcvd_pen_attr.s, USE_KOR_CC?TRUE:FALSE);
	
	if(pwin->rl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
		font_mh=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
	else
		font_mh=DCCGrp_GetMaxFontHeight(pwin->rcvd_pen_attr.s);
	
	r->w=pwin->cc*font_mw;

#if 0
	r->h=pwin->rc*font_mh;
#else
	if(pwin->rl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s)) {
		//°¢ ÇàÀÇ height¸¦ µÚÁ®¼­ °¡Àå ³ôÀº height¸¦ ãÀ½
		for(i=0, highest=-1; i<pwin->rc; i++) {
			if(pwin->text[i].h>highest) highest=pwin->text[i].h;
		}
		
		if(highest==-1 || font_mh>highest) highest=font_mh;
		
		r->h=pwin->rc*highest;
	}
	else
		r->h=pwin->rc*font_mh;
#endif

	new_ah=pwin->ah+INFO(user_posx);
	new_av=pwin->av+INFO(user_posy);
	
	if(new_ah<0) new_ah=0;
	if(new_ah>=100) new_ah=99;
	
	if(new_av<0) new_av=0;
	if(new_av>=100) new_av=99;
	
	switch(pwin->ap%3) {
		case 0 : r->x=DCCGrp_GetScrPosX(new_ah); break;
		case 1 : r->x=DCCGrp_GetScrPosX(new_ah)-r->w/2; break;
		case 2 : r->x=DCCGrp_GetScrPosX(new_ah)-r->w; break;
	}
	
	switch(pwin->ap/3) {
		case 0 : r->y=DCCGrp_GetScrPosY(new_av); break;
		case 1 : r->y=DCCGrp_GetScrPosY(new_av)-r->h/2; break;
		case 2 : r->y=DCCGrp_GetScrPosY(new_av)-r->h; break;
	}
	
	CCPRINT("win_rect", "before modify(%d,%d,%d,%d)\n", r->x, r->y, r->w, r->h);
	
	r->w+=2*CC_CH_DRAW_ADDING_WIDTH;
	r->x-=CC_CH_DRAW_ADDING_WIDTH;
	
	DCCGrp_AdjustRect(r);
	
	//width, height°¡ Ä¿Á³À¸¸é ÇØ´ç ³ÐÀ̸¸Å­ window¸¦ update½ÃÄÑ¾ß ÇÔ.
	//¾î¶»°Ô ¾÷µ¥ÀÌÆ® ÇÔ? 1. window¸¦ ´Ù½Ã ±×¸². 2. ³Ð¾îÁø ¿µ¿ª¸¸Å­¸¸ ¾÷µ¥ÀÌÆ®ÇÔ.
	if(pwin->v && (pwin->win_r.w>0 && pwin->win_r.h>0) 
		&& (r->w>pwin->win_r.w || r->h>pwin->win_r.h)) {
		int bg_color;
		
#if ENABLE_FLASH		
		if(pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
			bg_color=eDCC_C_TRANSPARENT;
		else 
#endif
			bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
	
		if(r->w>pwin->win_r.w) {
			DCCGrp_DrawBox(r->x+pwin->win_r.w, r->y, 
				r->w-pwin->win_r.w, r->h, bg_color);
		}
		
		if(r->h>pwin->win_r.h) {
			DCCGrp_DrawBox(r->x, r->y+pwin->win_r.h, 
				r->w, r->h-pwin->win_r.h, bg_color);
		}
	}
	
	if(pwin->win_r.x==r->x && pwin->win_r.y==r->y && pwin->win_r.w==r->w && pwin->win_r.h==r->h)
		is_changed=FALSE;
	else 
		is_changed=TRUE;
	
	if(!is_test)
		memcpy(&pwin->win_r, r, sizeof(pwin->win_r));
	
	CCPRINT("win_rect", "compute win rect(%d,%d,%d,%d)\n", r->x, r->y, r->w, r->h);
	CCPRINT("win_rect", "\tfrom id(%d), size(%d:%d), rl(%d), cl(%d), cc(%d), rc(%d), ah(%d), av(%d), ap(%d)\n", 
		pwin->id, pwin->pen_attr.s, pwin->rcvd_pen_attr.s, pwin->rl, pwin->cl, 
		pwin->cc, pwin->rc, pwin->ah, pwin->av, pwin->ap);
	
	return is_changed;
}


static int p_get_cur_xpos(tDCC_DefWin *pwin)
{
	int i;
	int len;
	
	for(i=0, len=0; i<pwin->cur_x; i++) {
		len+=pwin->text[pwin->cur_y].str[i].w;
	}
	
	return len;
}


static int p_update_line(tDCC_DefWin *pwin, UINT8 row)
{
	//ÇØ´ç row¿¡¼­ °¡Àå height°¡ ³ôÀº °ªÀ» ã¾Æ ¸®ÅÏÇÔ
	int i;
	int pos_y, height;
	int ret=0;
		
	if(row==0) 
		pos_y=0;
	else if(pwin->text[row-1].h>0) //Á¤»óÀûÀÎ °æ¿ì
		pos_y=pwin->text[row-1].y+pwin->text[row-1].h;
	else //°è»ê ÇÊ¿ä..±âÁØÀº ÇöÀç font »çÀÌÁî
		pos_y=row*DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);

	for(i=0, height=-1; i<MAX_NUM_COL; i++) {
		if(pwin->text[row].str[i].ch==0) break;//null ¹®ÀÚ°¡ ³ª¿À¸é Á¾·á
		
		if(height<pwin->text[row].str[i].h) height=pwin->text[row].str[i].h;
	}
	
	if(height==-1) {
		//ÀÌ °æ¿ì default font height°ªÀ» ³Ñ±ä´Ù.
		height=DCCGrp_GetMaxFontHeight(pwin->rl?pwin->pen_attr.s:pwin->rcvd_pen_attr.s);
	}

	CCPRINT("win_line", "win(%d), row(%d), line_yh(%d,%d)\n", 
		pwin->id, row, pos_y, height);
	
	if(pwin->text[row].y!=pos_y || pwin->text[row].h!=height) {
		if(pwin->text[row].h>0) ret=1;
		
		pwin->text[row].y=pos_y;
		pwin->text[row].h=height;
	}
	
	return ret;
}


#if 0
__Basic_Font_Func__()
#endif


static void p_set_pen_attr(tDCC_PenAttr *pattr)
{
	tDCC_PenAttr temp;
	
	memcpy(&temp, pattr, sizeof(temp));
	
	if(temp.fo==eDCC_O_FLASH && INFO(flash_fg)) temp.fo=eDCC_O_SOLID;
	if(temp.bo==eDCC_O_FLASH && INFO(flash_fg)) temp.bo=eDCC_O_SOLID;
	
	DCCGrp_SetFontAttr(&temp);
}


static void p_print_ch(int x, int y, tDCC_Char *pch, int draw_type)
{
	CCPRINT("win_ch2", "p_print_ch: xywh(%d,%d,%d,%d), ch(0x%x)\n", x, y, pch->w, pch->h, pch->ch);
	p_set_pen_attr(&pch->attr);
	DCCGrp_PrintCh(x, y, pch->ch, draw_type);
}


#if 0
__Draw_LV1_Func__()
#endif


static void p_draw_cur_win_ch(tDCC_DefWin *pwin, BOOL berase)
{
	//ÇØ´ç À§Ä¡ÀÇ ±ÛÀÚ¸¦ ±×¸°´Ù, justificationÀÌ leftÀÏ °æ¿ì¸¸ »ç¿ëµÊ.
	int pos_x, pos_y;
	tDCC_Line *pline=&pwin->text[pwin->cur_y];
	tDCC_Char *pch=&pwin->text[pwin->cur_y].str[pwin->cur_x];
	
	if(pch->ch==0) return; //ch°¡ NULLÀ̸é Áö¿ï ÇÊ¿ä ¾øÀ½.

	//justification
	pos_x=p_get_cur_xpos(pwin);
	
	if(pwin->win_attr.sd==eDCC_D_TPTOBT)
		pos_y=pwin->win_r.h-pline->y;
	else
		pos_y=pline->y+pline->h;

	if(0) { //->Áߺ¹µÇ´Â ÄÚµåÀÎ °Í °°Àºµ¥??
		int bg_color;
		
#if ENABLE_FLASH		
		if(pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
			bg_color=eDCC_C_TRANSPARENT;
		else 
#endif
			bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
		
		DCCGrp_DrawBox(pwin->win_r.x+pos_x, pwin->win_r.y+pos_y-pch->h,
			pch->w, pch->h, bg_color);
	}
	
	if(berase)
		memset(pch, 0, sizeof(*pch));
	else
		p_print_ch(pwin->win_r.x+pos_x+CC_CH_DRAW_ADDING_WIDTH, 
			pwin->win_r.y+pos_y-pch->h, pch, 
			pwin->cur_x==0?ePRIV_CH_DRAW_TYPE_ALL:ePRIV_CH_DRAW_TYPE_RIGHT);
}


static void p_draw_win_line(tDCC_DefWin *pwin, UINT8 row, BOOL bredraw)
{
	//ƯÁ¤ row¸¸ ±×¸²
	int i;
	int temp;
	int line_w;
	
	int pos_x, pos_y;
	
	tDCC_Line *pline=&pwin->text[row];
	tDCC_Char *pch;
	
	if(bredraw) {
		
		int bg_color;
		
#if ENABLE_FLASH		
		if(pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
			bg_color=eDCC_C_TRANSPARENT;
		else 
#endif
			bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
		
		DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y+pline->y,
			pwin->win_r.w, pline->h, bg_color);
	}
	
	for(i=0, line_w=0; pwin->text[row].str[i].ch; i++) 
		line_w+=pwin->text[row].str[i].w;

	//justification
	if(pwin->win_attr.j==eDCC_J_CENTER)
		pos_x=(pwin->win_r.w-line_w)/2;
	else if(pwin->win_attr.j==eDCC_J_RIGHT)
		pos_x=pwin->win_r.w-line_w;
	else
		pos_x=0;
	
	if(pwin->win_attr.sd==eDCC_D_TPTOBT)
		pos_y=pwin->win_r.h-pline->y;
	else
		pos_y=pline->y+pline->h;

	CCPRINT("win_line", "p_draw_win_line: row(%d), pos_xy(%d,%d)\n", row, pos_x, pos_y);
	
	//print
	for(i=0, temp=CC_CH_DRAW_ADDING_WIDTH; pline->str[i].ch; i++) { //¸Ç ¸¶Áö¸·Àº ¹«Á¶°Ç nullÀ̱⠶§¹®¿¡ ccÁ¶°ÇÀº »©µµ µÊ
		pch=&pline->str[i];
		p_print_ch(pwin->win_r.x+pos_x+temp, pwin->win_r.y+pos_y-pch->h, pch, 
		i==0?ePRIV_CH_DRAW_TYPE_ALL:ePRIV_CH_DRAW_TYPE_RIGHT);
		temp+=pch->w;
	}
		
}


static void p_draw_win_base(tDCC_DefWin *pwin, BOOL draw_bg, BOOL draw_fg, BOOL draw_trp)
{
	//ÇϳªÀÇ winÀ» ±×¸²
	if(!pwin->bcreated) return;
	if(!pwin->v) return;
		
	//window rect °áÁ¤
	// rectÀÇ x,yÁÂÇ¥´Â °íÁ¤. w, h´Â rl,clÀ» µû¶ó ±ÛÀÚ Å©±â·Î Á¤ÇÑ´Ù.
	// ¸¸ÀÏ rl, clÀÌ false¶ó¸é standard ±âÁØÀ¸·Î Á¤ÇÑ´Ù.
	// windowÀÇ Å©±â´Â °íÁ¤À̹ǷΠÇÑ ¹ø ±¸ÇÑ °ªÀ» win¿¡ ÀúÀåÇÑ´Ù.
	
	CCPRINT("win_draw", "win(%d), erase(%d), r(%d,%d,%d,%d)\n", 
		pwin->id, draw_trp, 
		pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, pwin->win_r.h);
	
	if(draw_trp || draw_bg) {
		int bg_color;
		
		if(draw_trp 
#if ENABLE_FLASH
			|| (pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
#endif
			)
			bg_color=eDCC_C_TRANSPARENT;
		else 
			bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
		
		DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, pwin->win_r.h, bg_color);
	}
	
	if(!draw_trp && draw_fg) {
		int i;
		
		for(i=0; i<pwin->rc; i++) {
			p_draw_win_line(pwin, i, TRUE);
		}
	}
}


static void p_delete_ch_list(tDCC_DefWin *pwin, int x, int y)
{
	int i;
	
	for(i=x; pwin->text[y].str[i].ch; i++) {
		memcpy(&pwin->text[y].str[i], &pwin->text[y].str[i+1], sizeof(tDCC_Char));
	}
}


static void p_get_ch_list(tDCC_DefWin *pwin, int x, int y)
{
	int i;
	
	for(i=x; pwin->text[y].str[i].ch; i++);
	
	for(; i>x; i--) {
		memcpy(&pwin->text[y].str[i], &pwin->text[y].str[i-1], sizeof(tDCC_Char));
	}
}


static void p_update_ch(tDCC_DefWin *pwin, int x, int y, UINT16 ch, BOOL is_p16, BOOL is_full_ch)
{
	pwin->text[y].str[x].ch=ch;
	memcpy(&pwin->text[y].str[x].attr, &pwin->pen_attr, sizeof(pwin->pen_attr));
	pwin->text[y].str[x].attr.p16=is_p16?1:0;
	
	pwin->text[y].str[x].full_ch=is_full_ch?1:0;
	pwin->text[y].str[x].pos=0;
	
	p_set_pen_attr(&pwin->text[y].str[x].attr);
	pwin->text[y].str[x].w=DCCGrp_GetChWidth(ch);
	pwin->text[y].str[x].h=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
	
	CCPRINT("win_d1", "p_update_ch(ch:0x%x): row(%d),col(%d), w(%d), h(%d), font_s(%d), pen_s(%d)\n",
		ch, y, x, pwin->text[y].str[x].w, pwin->text[y].str[x].h, pwin->pen_attr.fs, pwin->pen_attr.s);
}


static int p_update_ch_ex(tDCC_DefWin *pwin, int x, int y, UINT16 ch, BOOL is_p16, BOOL is_full_ch)
{
	/*Korean CC¿¡ ´ëÇÑ °í·Á ÇÊ¿ä

		N ¿ø·¡±ÛÀÚ | Ä¿¼­ À§Ä¡ | ´ÙÀ½ ±ÛÀÚ | ÀÔ·ÂµÉ ±ÛÀÚ | ¼³¸í
		1.¹ÝÀÚ       X           X           ¹ÝÀÚ          ±×´ë·Î ÀÔ·ÂÇÔ
		2.¹ÝÀÚ       X           ¹ÝÀÚ        ÀüÀÚ          ±×´ë·Î ÀÔ·Â, ´ÙÀ½ ±ÛÀÚµé ÇÑ Ä­¾¿ ¾ÕÀ¸·Î ´ç±è
		3.¹ÝÀÚ       X           ÀüÀÚ        ÀüÀÚ          ±×´ë·Î ÀÔ·Â, ´ÙÀ½ ±ÛÀÚ °ø¹é ó¸®
		4.ÀüÀÚ       0           X           ¹ÝÀÚ          ±×´ë·Î ÀÔ·Â, ´ÙÀ½ ±ÛÀÚ °ø¹é ó¸®, ÇÑ Ä­¾¿ ¹Ñ
		5.ÀüÀÚ       0           X           ÀüÀÚ          ±×´ë·Î ÀÔ·Â
		6.ÀüÀÚ       1           X           ¹ÝÀÚ          °ø¹é »ðÀÔ ÈÄ ÀÔ·Â,  ´ÙÀ½ ±ÛÀÚµé ÇÑ Ä­¾¿ ¹Ñ
		7.ÀüÀÚ       1           ¹ÝÀÚ        ÀüÀÚ          °ø¹é »ðÀÔ, ´ÙÀ½¿¡ ±ÛÀÚ ÀÔ·Â
		8.ÀüÀÚ       1           ÀüÀÚ        ÀüÀÚ          °ø¹é »ðÀÔ, ´ÙÀ½¿¡ ±ÛÀÚ ÀÔ·Â, ¶Ç °ø¹é »ðÀÔ, ´ÙÀ½ ±ÛÀÚ ÇÑ Ä­¾¿ ¹Ñ
	*/
	
	tDCC_Char *pch=&pwin->text[y].str[x];
	tDCC_Char *pnext=&pwin->text[y].str[x+1];
	int ret=0;
	
	if(pch->ch==0) {
		p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
		return 0;
	}
	
	if(pch->full_ch==0) { /* ±âÁ¸ ¹ÝÀÚ */
		if(!is_full_ch) 
			p_update_ch(pwin, x, y, ch, is_p16, is_full_ch); /* 1 */
		else {
			if(pnext->full_ch==0) { /* 2 */
				p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
				p_delete_ch_list(pwin, x+1, y);
				ret-=1;
			}
			else {/* 3 */
				p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
				p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
			}
		}
	}
	else { /* ±âÁ¸ ÀüÀÚ */
		if(pch->pos==0) {
			if(!is_full_ch) { /* 4 */
				p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
				p_get_ch_list(pwin, x+1, y);
				p_update_ch(pwin, x+1, y, ' ', FALSE, FALSE);
				ret+=1;
			}
			else { /* 5 */
				p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
			}
		}
		else {
			if(!is_full_ch) { /* 6 */
				p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
				p_get_ch_list(pwin, x+1, y);
				p_update_ch(pwin, x+1, y, ch, is_p16, is_full_ch);
				ret+=1;
			}
			else {
				if(pnext->full_ch==0) { /* 7 */
					p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
					p_update_ch(pwin, x+1, y, ch, is_p16, is_full_ch);
				}
				else { /* 8 */
					p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
					p_update_ch(pwin, x+1, y, ch, is_p16, is_full_ch);
					p_get_ch_list(pwin, x+2, y);
					p_update_ch(pwin, x+2, y, ' ', FALSE, FALSE);
					ret+=1;
				}
			}
			
		}
			
	}
	
	return ret;
}


static void p_insert_ch(tDCC_DefWin *pwin, UINT16 ch, UINT32 opt)
{
	int i;
	//ÇϳªÀÇ char°¡ ÀԷµǾúÀ½.
	BOOL is_p16=(opt&eDCC_OPT_P16)?TRUE:FALSE;
	BOOL is_608=(opt&eDCC_OPT_IS608)?TRUE:FALSE;
	BOOL is_cr=(opt&eDCC_OPT_CH_CR)?TRUE:FALSE;
	BOOL is_full_ch=(opt&eDCC_OPT_FULL_CH)?TRUE:FALSE;
	BOOL is_blank; /*±âÁ¸ char°¡ blankÀÎÁö ¿©ºÎ */
	BOOL is_line_change=FALSE;
	
	int max_width;
	int max_height;
	
	tDCC_Line *pline=&pwin->text[pwin->cur_y];
	
	if(!pwin->bcreated) {
		CCPRINT("win_ch", "window is not created\n");
		return;
	}
	
	CCPRINT("win_chex", "    1.cur pos xy(%d,%d)\n", pwin->cur_x, pwin->cur_y);
	
	//debug
	if(is_cr) {
		CCPRINT("win_ch", "insert cr\n");
	}
	else if(is_p16 && ch>=0x100) {	
		
		char buf[3];
		buf[0]=ch>>8;
		buf[1]=ch&0xff;
		buf[2]=0;
		
		CCPRINT("win_ch", "0x%x(%s), P16(yes)\n", ch, buf);
	}
	else {
		if(ch) {
			CCPRINT("win_ch", "0x%x(%c), P16(no)\n", ch, ch);
		}
	}
	
	//608ÀÎ °æ¿ì´Â Á» Ưº°ÇÏ°Ô Ã³¸®ÇÔ. Áï, cur_x°ªÀÌ 608 WIDTH º¸´Ù Ŭ °æ¿ì ±× °ªÀÌ °íÁ¤µÊ
	if(!is_cr) {
		if(is_608 && pwin->cur_x>=DCC_608_WIN_WIDTH) {
			CCPRINT("win_ch", "608 char is ignored because column is over width\n");
			return;
		}
	}
	
	if(pwin->cl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
		max_width=DCCGrp_GetMaxFontWidth(pwin->pen_attr.s, FALSE);
	else
		max_width=DCCGrp_GetMaxFontWidth(pwin->rcvd_pen_attr.s, FALSE);
	
	if(pwin->rl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
		max_height=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
	else
		max_height=DCCGrp_GetMaxFontHeight(pwin->rcvd_pen_attr.s);
	
	if(is_cr && pwin->cur_y>0 && pline->y==0 && pline->h==0) {
		//DFX, SPL ÈÄ ¹Ù·Î CRÀÌ µÚµû¸£´Â °æ¿ì cur_y°ªÀÌ À©µµ¿ì Å©±â¸¦ ³Ñ¾î°¥ ¼ö ÀÖÀ½
		//ÀÌ·± °æ¿ì ¸ÕÀú lineÀ» °è»êÇÏ´Â °ÍÀÌ ³ªÀ» °Í °°À½.
		p_update_line(pwin, pwin->cur_y);
	}
	
	if(pwin->win_r.h<pline->y+max_height) {
		/* ÇÑ ÁÙ Å©±â º¸´Ù ÀÛÀº windowÀÏ °æ¿ì, ±×¸®Áö ¾ÊÀ½ */
		CCPRINT("win_ch", "!! line info is bad(win_h(%d), line_y(%d), line_h(%d)\n",
			pwin->win_r.h, pline->y, max_height);
		return;
	}
	
	if(pwin->win_r.w<max_width) {
		/* width°¡ ¾ÆÁÖ ÀÛÀ» °æ¿ì ±×¸®Áö ¾ÊÀ½ */
		CCPRINT("win_chex", "width is very small(%d<%d)\n", pwin->win_r.w, max_width);
		return;
	}
	
	if(!is_608) //708ÀÎ °æ¿ì
	{		
		if(pwin->cur_x>=MAX_NUM_COL ||
			p_get_cur_xpos(pwin)+max_width>pwin->win_r.w ||
			is_cr)
		{
			//ccº¸´Ù Å« °æ¿ì, window¸¦ ³Ñ¾î°¡´Â °æ¿ì, CRÀÎ °æ¿ì ÁٹٲÞÀ» ÇÑ´Ù.
			is_line_change=TRUE;
			pwin->cur_x=0;
			CCPRINT("win_chex", "line is changed..row(%d) lineyh(%d,%d) winh(%d)\n",
				pwin->cur_y, pline->y, pline->h, pwin->win_r.h);

			if(pline->y+pline->h+max_height>pwin->win_r.h) {
				//ÁٹٲÞÀ» ÇÏ·Á´Ï±î °ø°£ÀÌ ºÎÁ·ÇÑ °æ¿ì -> scrollÀ» ÇØ¾ß ÇÔ.
				int scroll_h=pwin->text[0].h; 
				if(scroll_h==0) scroll_h=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
				
				CCPRINT("win_chex", "scroll is required..liney(%d) lineh(%d) winh(%d)\n",
					pline->y, pline->h, pwin->win_r.h);
				
				for(i=0; i<pwin->cur_y; i++) {
					memcpy(&pwin->text[i], &pwin->text[i+1], sizeof(pwin->text[i]));
					pwin->text[i].y-=scroll_h;
				}
				memset(&pwin->text[i], 0, sizeof(pwin->text[i]));
				
				if(pwin->v) { //visibleÀÎ °æ¿ì¸¸ ±×¸°´Ù.
					//scroll up/down
					//»ç¶óÁú(ù¹ø°) lineÀÇ ³ôÀ̸¦ scroll up/down ÇÔ.
					if(pwin->win_attr.sd==eDCC_D_TPTOBT) {
						CCPRINT("win_chex", "p_scroll_down\n");
						DCCGrp_ScrollDown(
							pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, pwin->win_r.h-scroll_h, 
							scroll_h, p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
						DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, scroll_h,
							p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
					}
					else {
						CCPRINT("win_chex", "p_scroll_up\n");
						DCCGrp_ScrollUp(pwin->win_r.x, pwin->win_r.y+scroll_h, 
							pwin->win_r.w, pwin->win_r.h-scroll_h, scroll_h,
							p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
						DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y+pwin->win_r.h-scroll_h, 
							pwin->win_r.w, scroll_h, p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
					}
				}
			}
			else {
				pwin->cur_y++; //´Ü¼øÈ÷ ÁٹٲÞÇÔ.
				
#if DEL_LINE_BEFORE_WRITING 
				//ÁٹٲÞÇÒ ¶§ ¹öÆÛ¸¦ Áö¿ö¾ß ÇÏ´Â °æ¿ì..justificationÀÌ center, right´Â Áö¿ö¾ß ÇÔ.
				if(pwin->win_attr.j!=eDCC_J_LEFT) {
					memset(&pwin->text[pwin->cur_y], 0, sizeof(pwin->text[pwin->cur_y]));
					if(pwin->v) //visibleÀÎ °æ¿ì¸¸ ±×¸°´Ù.
						p_draw_win_line(pwin, pwin->cur_y, TRUE);
				}
			}
#endif
		}
	}

#if 0	
	is_blank=pwin->text[pwin->cur_y].str[pwin->cur_x].ch==0?TRUE:FALSE;
#else
	is_blank=TRUE;
#endif

	if(!is_cr)
		pwin->cur_x+=p_update_ch_ex(pwin, pwin->cur_x, pwin->cur_y, ch, is_p16, is_full_ch);
	
	//line ¾÷µ¥ÀÌÆ® 	
	if(p_update_line(pwin, pwin->cur_y)==1) {
		//lineÀÇ ³ôÀÌ°¡ º¯°æµÇ¾úÀ¸¹Ç·Î lineÀ» ´Ù½Ã ±×·Á¾ß ÇÔ.
		if(pwin->v && !is_cr) 
			p_draw_win_line(pwin, pwin->cur_y, TRUE);
	}	
	//left´Â ±ÛÀÚ¸¸ Âï°í, ÀÌ¿Ü´Â ÇÑ ÁÙ Àüü¸¦ ´Ù½Ã ±×·Á¾ß ÇÔ.
	//608ÀÎ °æ¿ì´Â ¹«Á¶°Ç µ¤¾î ¾¸
	else if(is_608 || (pwin->win_attr.j==eDCC_J_LEFT && is_blank))	{
		if(pwin->v && !is_cr) 
			p_draw_cur_win_ch(pwin, FALSE);
	} 
	else {
		if(pwin->v && !is_cr) 
			p_draw_win_line(pwin, pwin->cur_y, TRUE);
	}
	
	//if(!is_line_change) pwin->cur_x++;
	if(!is_cr) pwin->cur_x++;
		
	CCPRINT("win_chex", "    cur pos xy(%d,%d)\n", pwin->cur_x, pwin->cur_y);
	
}


static void p_erase_ch(tDCC_DefWin *pwin)
{
	//backspace 󸮿ë
	int i;
	
	CCPRINT("ch1", "p_erase_ch\n");
	
	p_update_line(pwin, pwin->cur_y);
	p_draw_cur_win_ch(pwin, TRUE);
	
	if(pwin->cur_x==0) {
		if(pwin->cur_y==0) return;
		
		for(i=0; pwin->text[--pwin->cur_y].str[i].ch; i++)
			pwin->cur_x++;
		
		if(pwin->cur_x>0) pwin->cur_x--;
		
	}
	else {
		pwin->cur_x--;
	}
	
	p_update_line(pwin, pwin->cur_y);
	
	p_draw_cur_win_ch(pwin, TRUE);
}


#if 0
__Draw_LV2_Func__()
#endif
 

static void p_draw_win(tDCC_DefWin *pwin, BOOL draw_bg, BOOL draw_fg, BOOL draw_trp)
{
	//°ãÄ¡´Â window°¡ ÀÖ´ÂÁö È®ÀÎÇÏ¿© ÀÖÀ¸¸é ±× window¸¦ ´Ù½Ã ±×·ÁÁà¾ß ÇÔ.
	int i;

	p_draw_win_base(pwin, draw_bg, draw_fg, draw_trp);
	
	for(i=0; i<pwin->num_overlap_win; i++) {
		p_draw_win_base(&p_dfw[pwin->overlap_win[i]], TRUE, TRUE, draw_trp);
	}
}


static void p_draw_all_win()
{
	int i;
	
	for(i=INFO(num_win_list)-1; i>=0; i--) {
		p_draw_win_base(&p_dfw[INFO(win_list)[i]], TRUE, TRUE, FALSE);
	}
}


static void p_draw_flash_wins()
{
	/* comment
		flash´Â overlapµÇ´Â winÀÌ ¾ø´Â window¿¡¼­¸¸ µ¿À۵ȴÙ.
	*/
#if ENABLE_FLASH
	int i, idx;
	
	for(i=INFO(num_win_list)-1; i>=0; i--) {
		
		idx=INFO(win_list)[i];
		
#if FLASHING_ONLY_FRONT_WIN
		if(p_dfw[idx].num_overlap_win>0) continue;
#endif
		
		if(p_dfw[idx].win_attr.fo==eDCC_O_FLASH)
			p_draw_win_base(&p_dfw[idx], TRUE, TRUE, FALSE);
		else if(p_dfw[idx].pen_attr.fo==eDCC_O_FLASH || p_dfw[idx].pen_attr.bo==eDCC_O_FLASH)
			p_draw_win_base(&p_dfw[idx], FALSE, TRUE, FALSE);
	}
#endif
	
}


#if 0
___Update_Attr__()
#endif


//win
tDCC_DefWin *DCCWin_GetWin(int wid)
{
	return &p_dfw[wid];
}


void DCCWin_DrawWin(int wid, BOOL draw_bg, BOOL draw_fg)
{
	p_draw_win(&p_dfw[wid], draw_bg, draw_fg, FALSE);
}


void DCCWin_EraseWin(int wid)
{
	p_draw_win(&p_dfw[wid], FALSE, FALSE, TRUE);
}


void DCCWin_DrawAllWins()
{
	p_draw_all_win();
}


void DCCWin_DrawFlashWins()
{
	p_draw_flash_wins();
}


void DCCWin_ResetWin(int wid)
{
	memset(&p_dfw[wid], 0, sizeof(p_dfw[wid]));
}


void DCCWin_ResetTextPos(int wid)
{
	memset(&p_dfw[wid].text, 0, sizeof(p_dfw[wid].text));
	p_dfw[wid].cur_x=0;
	p_dfw[wid].cur_y=0;
}


void DCCWin_ResetTextOnly(int wid)
{
	memset(&p_dfw[wid].text, 0, sizeof(p_dfw[wid].text));
}


void DCCWin_ResetAllWins(BOOL berase_screen)
{
	memset(p_dfw, 0, sizeof(p_dfw));
	
	if(berase_screen) DCCGrp_ClearScreen();
}


void DCCWin_UpdateWinRect(int wid)
{
	//pen size ¼³Á¤
	p_set_pen_attr(&p_dfw[wid].pen_attr); //ÁÂÇ¥ °è»êÀ» Çϱâ Àü pen attrÀ» ¸ÕÀú ¼³Á¤ÇÔ.
	p_get_win_rect(&p_dfw[wid], FALSE);
}

BOOL DCCWin_CheckWinRect(int wid)
{
	p_set_pen_attr(&p_dfw[wid].pen_attr); //ÁÂÇ¥ °è»êÀ» Çϱâ Àü pen attrÀ» ¸ÕÀú ¼³Á¤ÇÔ.
	return p_get_win_rect(&p_dfw[wid], TRUE);
}


void DCCWin_UpdateWinAttr()
{
	//win overlap ÀçÁ¡°Ë.
	p_update_overlap_win();
}


//line
void DCCWin_EraseCurLine(int wid, BOOL is_der)
{
	int i;
	tDCC_DefWin *pwin=DCCWin_GetWin(wid);
	
	if(is_der) {
		//608ÀÇ der ¸ðµå·Î µ¿ÀÛ, ÇöÀçºÎÅÍ ³¡±îÁö¸¦ ´Ù Áö¿ò
		for(i=pwin->cur_x; i<MAX_NUM_COL+1; i++)
			memset(&pwin->text[pwin->cur_y].str[i], 0, sizeof(pwin->text[pwin->cur_y].str[i]));
		//line ¾÷µ¥ÀÌÆ®
		p_draw_win_line(pwin, pwin->cur_y, TRUE);
	}
	else {
		//line Àüü¸¦ Áö¿ì°í cursor¸¦ ¸¸ ¾Õ À§Ä¡·Î º¯°æ
		memset(&pwin->text[pwin->cur_y].str, 0, sizeof(pwin->text[pwin->cur_y].str));
		pwin->cur_x=0;
		p_draw_win_line(pwin, pwin->cur_y, TRUE);
	}
	
}


void DCCWin_FillTrpToLine(int wid)
{
	//ÇöÀç row¿¡¼­ ÇØ´ç col±îÁö NULLÀÌ ÀÖÀ¸¸é ' '·Î ä¿ö³ÖÀ½
	int i;
	tDCC_DefWin *pwin=DCCWin_GetWin(wid);
	
	for(i=0; i<pwin->cur_x; i++) {
		if(pwin->text[pwin->cur_y].str[i].ch==0)
			p_update_ch(pwin, i, pwin->cur_y, DCC_TRP_CODE, FALSE, FALSE);
	}
}


//char
void DCCWin_InsertCh(int wid, UINT16 ch, UINT32 opt)
{
	p_insert_ch(&p_dfw[wid], ch, opt);
	
}


void DCCWin_EraseCh(int wid)
{
	p_erase_ch(&p_dfw[wid]);
}


void DCCWin_UpdateLine(int wid, int row)
{
	tDCC_DefWin *pwin=DCCWin_GetWin(wid);
	
	p_update_line(pwin, row);
}


void DCCWin_ToggleFlashFlag()
{
	INFO(flash_fg)=INFO(flash_fg)?FALSE:TRUE;
}


void DCCWin_SetUserPos(int x, int y)
{
	INFO(user_posx)=x;
	INFO(user_posy)=y;
}