source: svn/newcon3bcm2_21bu/dst/dmw/src/cc/cc_win.c @ 76

Last change on this file since 76 was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 24.1 KB
Line 
1
2#include "cc_config.h"
3#include "cc_type.h"
4#include "cc_def.h"
5#include "cc_private.h"
6
7static tDCC_DefWin p_dfw[8];
8
9static struct {
10        BOOL flash_fg;
11        int user_posx;
12        int user_posy;
13        UINT8 win_list[8]; /* °¡Àå prio°¡ ³ôÀº winºÎÅÍ ³·Àº ¼øÀ¸·Î Á¤·ÄµÊ */
14        UINT8 num_win_list;
15       
16} p_win_info;
17
18#define INFO(i) p_win_info.i
19
20
21#if 0
22__Basic_Misc_Func__()
23#endif
24
25
26static UINT8 p_get_color(UINT8 c, UINT8 o)
27{
28        UINT8 ret=0;
29
30        if(o==eDCC_O_FLASH) {
31#if ENABLE_FLASH
32                o=eDCC_O_SOLID;
33                if(INFO(flash_fg)==0) c=eDCC_C_NONE;
34#else
35                ret = c;
36#endif
37        }       
38
39        if(o==eDCC_O_SOLID)
40                ret = c;
41        else if(o==eDCC_O_TRANSLUCENT)
42                ret = c | 0x8;
43        else if(o==eDCC_O_TRANSPARENT)
44                ret = eDCC_C_TRANSPARENT;
45       
46        return ret;
47}
48
49
50
51#if 0
52__Basic_Win_Func__()
53#endif
54
55
56static BOOL p_is_dot_in_rect(int x, int y, tDCC_RECT *pr)
57{
58        return ((x>=pr->x && x<=pr->x+pr->w) && (y>=pr->y && y<=pr->y+pr->h));
59}
60
61
62static BOOL p_is_rect_overlap(tDCC_RECT *pr1, tDCC_RECT *pr2)
63{
64        if(p_is_dot_in_rect(pr2->x, pr2->y, pr1)) return TRUE;
65        if(p_is_dot_in_rect(pr2->x+pr2->w, pr2->y, pr1)) return TRUE;
66        if(p_is_dot_in_rect(pr2->x, pr2->y+pr2->h, pr1)) return TRUE;
67        if(p_is_dot_in_rect(pr2->x+pr2->w, pr2->y+pr2->h, pr1)) return TRUE;
68       
69        if(p_is_dot_in_rect(pr1->x, pr1->y, pr2)) return TRUE;
70        if(p_is_dot_in_rect(pr1->x+pr1->w, pr1->y, pr2)) return TRUE;
71        if(p_is_dot_in_rect(pr1->x, pr1->y+pr1->h, pr2)) return TRUE;
72        if(p_is_dot_in_rect(pr1->x+pr1->w, pr1->y+pr1->h, pr2)) return TRUE;
73       
74        return FALSE;
75}
76
77
78static BOOL p_is_win_overlap(tDCC_DefWin *pwin1, tDCC_DefWin *pwin2)
79{
80        if(!pwin1->bcreated || !pwin1->v) return FALSE;
81        if(!pwin2->bcreated || !pwin2->v) return FALSE;
82
83        return p_is_rect_overlap(&pwin1->win_r, &pwin2->win_r);
84}
85
86
87static void p_update_overlap_win()
88{
89        //overlap
90        int i, j;
91        int temp;
92       
93        for(i=0, INFO(num_win_list)=0; i<8; i++) {
94                if(!p_dfw[i].bcreated || !p_dfw[i].v) continue;
95                INFO(win_list)[INFO(num_win_list)++]=(UINT8)i;
96        }
97       
98        /* 1. win_list¿¡ Á¤·Ä */
99        for(i=0; i<INFO(num_win_list)-1; i++) {
100                for(j=0; j<INFO(num_win_list)-i-1; j++) {
101                        if((p_dfw[j].p > p_dfw[j+1].p) || 
102                                ((p_dfw[j].p == p_dfw[j+1].p) && (p_dfw[j].id_draw > p_dfw[j+1].id_draw))) {
103                                /* swap */
104                                temp=INFO(win_list)[j];
105                                INFO(win_list)[j]=INFO(win_list)[j+1];
106                                INFO(win_list)[j+1]=temp;
107                        }
108                }
109        }
110       
111        /* Á¤·ÄµÈ win_list¸¦ º¸°í °¢°¢ÀÇ dfw¿¡ overlap winÀ» ¾÷µ¥ÀÌÆ®ÇÔ */
112        for(i=INFO(num_win_list)-1; i>0; i--) {
113                int overlap_idx=0;
114               
115                for(j=i-1; j>=0; j--) {
116                        if(!p_is_win_overlap(&p_dfw[INFO(win_list)[i]], &p_dfw[INFO(win_list)[j]])) continue;
117                       
118                        p_dfw[INFO(win_list)[i]].overlap_win[overlap_idx++]=INFO(win_list)[j];
119                }
120                p_dfw[INFO(win_list)[i]].num_overlap_win=overlap_idx;
121        }
122
123}
124
125
126static BOOL p_get_win_rect(tDCC_DefWin *pwin, BOOL is_test)
127{
128        int i;
129        int new_ah, new_av;
130        tDCC_RECT temp, *r=&temp;
131        int highest;
132        BOOL is_changed=FALSE;
133        int font_mw, font_mh;
134       
135        if(!pwin->bcreated) return FALSE;
136       
137        memset(r, 0, sizeof(*r));
138
139        if(pwin->cl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
140                font_mw=DCCGrp_GetMaxFontWidth(pwin->pen_attr.s, USE_KOR_CC?TRUE:FALSE);
141        else
142                font_mw=DCCGrp_GetMaxFontWidth(pwin->rcvd_pen_attr.s, USE_KOR_CC?TRUE:FALSE);
143       
144        if(pwin->rl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
145                font_mh=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
146        else
147                font_mh=DCCGrp_GetMaxFontHeight(pwin->rcvd_pen_attr.s);
148       
149        r->w=pwin->cc*font_mw;
150
151#if 0
152        r->h=pwin->rc*font_mh;
153#else
154        if(pwin->rl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s)) {
155                //°¢ ÇàÀÇ height¸¦ µÚÁ®¼­ °¡Àå ³ôÀº height¸¦ ãÀ½
156                for(i=0, highest=-1; i<pwin->rc; i++) {
157                        if(pwin->text[i].h>highest) highest=pwin->text[i].h;
158                }
159               
160                if(highest==-1 || font_mh>highest) highest=font_mh;
161               
162                r->h=pwin->rc*highest;
163        }
164        else
165                r->h=pwin->rc*font_mh;
166#endif
167
168        new_ah=pwin->ah+INFO(user_posx);
169        new_av=pwin->av+INFO(user_posy);
170       
171        if(new_ah<0) new_ah=0;
172        if(new_ah>=100) new_ah=99;
173       
174        if(new_av<0) new_av=0;
175        if(new_av>=100) new_av=99;
176       
177        switch(pwin->ap%3) {
178                case 0 : r->x=DCCGrp_GetScrPosX(new_ah); break;
179                case 1 : r->x=DCCGrp_GetScrPosX(new_ah)-r->w/2; break;
180                case 2 : r->x=DCCGrp_GetScrPosX(new_ah)-r->w; break;
181        }
182       
183        switch(pwin->ap/3) {
184                case 0 : r->y=DCCGrp_GetScrPosY(new_av); break;
185                case 1 : r->y=DCCGrp_GetScrPosY(new_av)-r->h/2; break;
186                case 2 : r->y=DCCGrp_GetScrPosY(new_av)-r->h; break;
187        }
188       
189        CCPRINT("win_rect", "before modify(%d,%d,%d,%d)\n", r->x, r->y, r->w, r->h);
190       
191        r->w+=2*CC_CH_DRAW_ADDING_WIDTH;
192        r->x-=CC_CH_DRAW_ADDING_WIDTH;
193       
194        DCCGrp_AdjustRect(r);
195       
196        //width, height°¡ Ä¿Á³À¸¸é ÇØ´ç ³ÐÀ̸¸Å­ window¸¦ update½ÃÄÑ¾ß ÇÔ.
197        //¾î¶»°Ô ¾÷µ¥ÀÌÆ® ÇÔ? 1. window¸¦ ´Ù½Ã ±×¸². 2. ³Ð¾îÁø ¿µ¿ª¸¸Å­¸¸ ¾÷µ¥ÀÌÆ®ÇÔ.
198        if(pwin->v && (pwin->win_r.w>0 && pwin->win_r.h>0) 
199                && (r->w>pwin->win_r.w || r->h>pwin->win_r.h)) {
200                int bg_color;
201               
202#if ENABLE_FLASH               
203                if(pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
204                        bg_color=eDCC_C_TRANSPARENT;
205                else 
206#endif
207                        bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
208       
209                if(r->w>pwin->win_r.w) {
210                        DCCGrp_DrawBox(r->x+pwin->win_r.w, r->y, 
211                                r->w-pwin->win_r.w, r->h, bg_color);
212                }
213               
214                if(r->h>pwin->win_r.h) {
215                        DCCGrp_DrawBox(r->x, r->y+pwin->win_r.h, 
216                                r->w, r->h-pwin->win_r.h, bg_color);
217                }
218        }
219       
220        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)
221                is_changed=FALSE;
222        else 
223                is_changed=TRUE;
224       
225        if(!is_test)
226                memcpy(&pwin->win_r, r, sizeof(pwin->win_r));
227       
228        CCPRINT("win_rect", "compute win rect(%d,%d,%d,%d)\n", r->x, r->y, r->w, r->h);
229        CCPRINT("win_rect", "\tfrom id(%d), size(%d:%d), rl(%d), cl(%d), cc(%d), rc(%d), ah(%d), av(%d), ap(%d)\n", 
230                pwin->id, pwin->pen_attr.s, pwin->rcvd_pen_attr.s, pwin->rl, pwin->cl, 
231                pwin->cc, pwin->rc, pwin->ah, pwin->av, pwin->ap);
232       
233        return is_changed;
234}
235
236
237static int p_get_cur_xpos(tDCC_DefWin *pwin)
238{
239        int i;
240        int len;
241       
242        for(i=0, len=0; i<pwin->cur_x; i++) {
243                len+=pwin->text[pwin->cur_y].str[i].w;
244        }
245       
246        return len;
247}
248
249
250static int p_update_line(tDCC_DefWin *pwin, UINT8 row)
251{
252        //ÇØ´ç row¿¡¼­ °¡Àå height°¡ ³ôÀº °ªÀ» ã¾Æ ¸®ÅÏÇÔ
253        int i;
254        int pos_y, height;
255        int ret=0;
256               
257        if(row==0) 
258                pos_y=0;
259        else if(pwin->text[row-1].h>0) //Á¤»óÀûÀÎ °æ¿ì
260                pos_y=pwin->text[row-1].y+pwin->text[row-1].h;
261        else //°è»ê ÇÊ¿ä..±âÁØÀº ÇöÀç font »çÀÌÁî
262                pos_y=row*DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
263
264        for(i=0, height=-1; i<MAX_NUM_COL; i++) {
265                if(pwin->text[row].str[i].ch==0) break;//null ¹®ÀÚ°¡ ³ª¿À¸é Á¾·á
266               
267                if(height<pwin->text[row].str[i].h) height=pwin->text[row].str[i].h;
268        }
269       
270        if(height==-1) {
271                //ÀÌ °æ¿ì default font height°ªÀ» ³Ñ±ä´Ù.
272                height=DCCGrp_GetMaxFontHeight(pwin->rl?pwin->pen_attr.s:pwin->rcvd_pen_attr.s);
273        }
274
275        CCPRINT("win_line", "win(%d), row(%d), line_yh(%d,%d)\n", 
276                pwin->id, row, pos_y, height);
277       
278        if(pwin->text[row].y!=pos_y || pwin->text[row].h!=height) {
279                if(pwin->text[row].h>0) ret=1;
280               
281                pwin->text[row].y=pos_y;
282                pwin->text[row].h=height;
283        }
284       
285        return ret;
286}
287
288
289#if 0
290__Basic_Font_Func__()
291#endif
292
293
294static void p_set_pen_attr(tDCC_PenAttr *pattr)
295{
296        tDCC_PenAttr temp;
297       
298        memcpy(&temp, pattr, sizeof(temp));
299       
300        if(temp.fo==eDCC_O_FLASH && INFO(flash_fg)) temp.fo=eDCC_O_SOLID;
301        if(temp.bo==eDCC_O_FLASH && INFO(flash_fg)) temp.bo=eDCC_O_SOLID;
302       
303        DCCGrp_SetFontAttr(&temp);
304}
305
306
307static void p_print_ch(int x, int y, tDCC_Char *pch, int draw_type)
308{
309        CCPRINT("win_ch2", "p_print_ch: xywh(%d,%d,%d,%d), ch(0x%x)\n", x, y, pch->w, pch->h, pch->ch);
310        p_set_pen_attr(&pch->attr);
311        DCCGrp_PrintCh(x, y, pch->ch, draw_type);
312}
313
314
315#if 0
316__Draw_LV1_Func__()
317#endif
318
319
320static void p_draw_cur_win_ch(tDCC_DefWin *pwin, BOOL berase)
321{
322        //ÇØ´ç À§Ä¡ÀÇ ±ÛÀÚ¸¦ ±×¸°´Ù, justificationÀÌ leftÀÏ °æ¿ì¸¸ »ç¿ëµÊ.
323        int pos_x, pos_y;
324        tDCC_Line *pline=&pwin->text[pwin->cur_y];
325        tDCC_Char *pch=&pwin->text[pwin->cur_y].str[pwin->cur_x];
326       
327        if(pch->ch==0) return; //ch°¡ NULLÀ̸é Áö¿ï ÇÊ¿ä ¾øÀ½.
328
329        //justification
330        pos_x=p_get_cur_xpos(pwin);
331       
332        if(pwin->win_attr.sd==eDCC_D_TPTOBT)
333                pos_y=pwin->win_r.h-pline->y;
334        else
335                pos_y=pline->y+pline->h;
336
337        if(0) { //->Áߺ¹µÇ´Â ÄÚµåÀÎ °Í °°Àºµ¥??
338                int bg_color;
339               
340#if ENABLE_FLASH               
341                if(pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
342                        bg_color=eDCC_C_TRANSPARENT;
343                else 
344#endif
345                        bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
346               
347                DCCGrp_DrawBox(pwin->win_r.x+pos_x, pwin->win_r.y+pos_y-pch->h,
348                        pch->w, pch->h, bg_color);
349        }
350       
351        if(berase)
352                memset(pch, 0, sizeof(*pch));
353        else
354                p_print_ch(pwin->win_r.x+pos_x+CC_CH_DRAW_ADDING_WIDTH, 
355                        pwin->win_r.y+pos_y-pch->h, pch, 
356                        pwin->cur_x==0?ePRIV_CH_DRAW_TYPE_ALL:ePRIV_CH_DRAW_TYPE_RIGHT);
357}
358
359
360static void p_draw_win_line(tDCC_DefWin *pwin, UINT8 row, BOOL bredraw)
361{
362        //ƯÁ¤ row¸¸ ±×¸²
363        int i;
364        int temp;
365        int line_w;
366       
367        int pos_x, pos_y;
368       
369        tDCC_Line *pline=&pwin->text[row];
370        tDCC_Char *pch;
371       
372        if(bredraw) {
373               
374                int bg_color;
375               
376#if ENABLE_FLASH               
377                if(pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
378                        bg_color=eDCC_C_TRANSPARENT;
379                else 
380#endif
381                        bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
382               
383                DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y+pline->y,
384                        pwin->win_r.w, pline->h, bg_color);
385        }
386       
387        for(i=0, line_w=0; pwin->text[row].str[i].ch; i++) 
388                line_w+=pwin->text[row].str[i].w;
389
390        //justification
391        if(pwin->win_attr.j==eDCC_J_CENTER)
392                pos_x=(pwin->win_r.w-line_w)/2;
393        else if(pwin->win_attr.j==eDCC_J_RIGHT)
394                pos_x=pwin->win_r.w-line_w;
395        else
396                pos_x=0;
397       
398        if(pwin->win_attr.sd==eDCC_D_TPTOBT)
399                pos_y=pwin->win_r.h-pline->y;
400        else
401                pos_y=pline->y+pline->h;
402
403        CCPRINT("win_line", "p_draw_win_line: row(%d), pos_xy(%d,%d)\n", row, pos_x, pos_y);
404       
405        //print
406        for(i=0, temp=CC_CH_DRAW_ADDING_WIDTH; pline->str[i].ch; i++) { //¸Ç ¸¶Áö¸·Àº ¹«Á¶°Ç nullÀ̱⠶§¹®¿¡ ccÁ¶°ÇÀº »©µµ µÊ
407                pch=&pline->str[i];
408                p_print_ch(pwin->win_r.x+pos_x+temp, pwin->win_r.y+pos_y-pch->h, pch, 
409                i==0?ePRIV_CH_DRAW_TYPE_ALL:ePRIV_CH_DRAW_TYPE_RIGHT);
410                temp+=pch->w;
411        }
412               
413}
414
415
416static void p_draw_win_base(tDCC_DefWin *pwin, BOOL draw_bg, BOOL draw_fg, BOOL draw_trp)
417{
418        //ÇϳªÀÇ winÀ» ±×¸²
419        if(!pwin->bcreated) return;
420        if(!pwin->v) return;
421               
422        //window rect °áÁ¤
423        // rectÀÇ x,yÁÂÇ¥´Â °íÁ¤. w, h´Â rl,clÀ» µû¶ó ±ÛÀÚ Å©±â·Î Á¤ÇÑ´Ù.
424        // ¸¸ÀÏ rl, clÀÌ false¶ó¸é standard ±âÁØÀ¸·Î Á¤ÇÑ´Ù.
425        // windowÀÇ Å©±â´Â °íÁ¤À̹ǷΠÇÑ ¹ø ±¸ÇÑ °ªÀ» win¿¡ ÀúÀåÇÑ´Ù.
426       
427        CCPRINT("win_draw", "win(%d), erase(%d), r(%d,%d,%d,%d)\n", 
428                pwin->id, draw_trp, 
429                pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, pwin->win_r.h);
430       
431        if(draw_trp || draw_bg) {
432                int bg_color;
433               
434                if(draw_trp
435#if ENABLE_FLASH
436                        || (pwin->win_attr.fo==eDCC_O_FLASH && INFO(flash_fg)==0)
437#endif
438                        )
439                        bg_color=eDCC_C_TRANSPARENT;
440                else 
441                        bg_color=p_get_color(pwin->win_attr.fc, pwin->win_attr.fo);
442               
443                DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, pwin->win_r.h, bg_color);
444        }
445       
446        if(!draw_trp && draw_fg) {
447                int i;
448               
449                for(i=0; i<pwin->rc; i++) {
450                        p_draw_win_line(pwin, i, TRUE);
451                }
452        }
453}
454
455
456static void p_delete_ch_list(tDCC_DefWin *pwin, int x, int y)
457{
458        int i;
459       
460        for(i=x; pwin->text[y].str[i].ch; i++) {
461                memcpy(&pwin->text[y].str[i], &pwin->text[y].str[i+1], sizeof(tDCC_Char));
462        }
463}
464
465
466static void p_get_ch_list(tDCC_DefWin *pwin, int x, int y)
467{
468        int i;
469       
470        for(i=x; pwin->text[y].str[i].ch; i++);
471       
472        for(; i>x; i--) {
473                memcpy(&pwin->text[y].str[i], &pwin->text[y].str[i-1], sizeof(tDCC_Char));
474        }
475}
476
477
478static void p_update_ch(tDCC_DefWin *pwin, int x, int y, UINT16 ch, BOOL is_p16, BOOL is_full_ch)
479{
480        pwin->text[y].str[x].ch=ch;
481        memcpy(&pwin->text[y].str[x].attr, &pwin->pen_attr, sizeof(pwin->pen_attr));
482        pwin->text[y].str[x].attr.p16=is_p16?1:0;
483       
484        pwin->text[y].str[x].full_ch=is_full_ch?1:0;
485        pwin->text[y].str[x].pos=0;
486       
487        p_set_pen_attr(&pwin->text[y].str[x].attr);
488        pwin->text[y].str[x].w=DCCGrp_GetChWidth(ch);
489        pwin->text[y].str[x].h=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
490       
491        CCPRINT("win_d1", "p_update_ch(ch:0x%x): row(%d),col(%d), w(%d), h(%d), font_s(%d), pen_s(%d)\n",
492                ch, y, x, pwin->text[y].str[x].w, pwin->text[y].str[x].h, pwin->pen_attr.fs, pwin->pen_attr.s);
493}
494
495
496static int p_update_ch_ex(tDCC_DefWin *pwin, int x, int y, UINT16 ch, BOOL is_p16, BOOL is_full_ch)
497{
498        /*Korean CC¿¡ ´ëÇÑ °í·Á ÇÊ¿ä
499
500                N ¿ø·¡±ÛÀÚ | Ä¿¼­ À§Ä¡ | ´ÙÀ½ ±ÛÀÚ | ÀÔ·ÂµÉ ±ÛÀÚ | ¼³¸í
501                1.¹ÝÀÚ       X           X           ¹ÝÀÚ          ±×´ë·Î ÀÔ·ÂÇÔ
502                2.¹ÝÀÚ       X           ¹ÝÀÚ        ÀüÀÚ          ±×´ë·Î ÀÔ·Â, ´ÙÀ½ ±ÛÀÚµé ÇÑ Ä­¾¿ ¾ÕÀ¸·Î ´ç±è
503                3.¹ÝÀÚ       X           ÀüÀÚ        ÀüÀÚ          ±×´ë·Î ÀÔ·Â, ´ÙÀ½ ±ÛÀÚ °ø¹é ó¸®
504                4.ÀüÀÚ       0           X           ¹ÝÀÚ          ±×´ë·Î ÀÔ·Â, ´ÙÀ½ ±ÛÀÚ °ø¹é ó¸®, ÇÑ Ä­¾¿ ¹Ñ
505                5.ÀüÀÚ       0           X           ÀüÀÚ          ±×´ë·Î ÀÔ·Â
506                6.ÀüÀÚ       1           X           ¹ÝÀÚ          °ø¹é »ðÀÔ ÈÄ ÀÔ·Â,  ´ÙÀ½ ±ÛÀÚµé ÇÑ Ä­¾¿ ¹Ñ
507                7.ÀüÀÚ       1           ¹ÝÀÚ        ÀüÀÚ          °ø¹é »ðÀÔ, ´ÙÀ½¿¡ ±ÛÀÚ ÀÔ·Â
508                8.ÀüÀÚ       1           ÀüÀÚ        ÀüÀÚ          °ø¹é »ðÀÔ, ´ÙÀ½¿¡ ±ÛÀÚ ÀÔ·Â, ¶Ç °ø¹é »ðÀÔ, ´ÙÀ½ ±ÛÀÚ ÇÑ Ä­¾¿ ¹Ñ
509        */
510       
511        tDCC_Char *pch=&pwin->text[y].str[x];
512        tDCC_Char *pnext=&pwin->text[y].str[x+1];
513        int ret=0;
514       
515        if(pch->ch==0) {
516                p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
517                return 0;
518        }
519       
520        if(pch->full_ch==0) { /* ±âÁ¸ ¹ÝÀÚ */
521                if(!is_full_ch) 
522                        p_update_ch(pwin, x, y, ch, is_p16, is_full_ch); /* 1 */
523                else {
524                        if(pnext->full_ch==0) { /* 2 */
525                                p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
526                                p_delete_ch_list(pwin, x+1, y);
527                                ret-=1;
528                        }
529                        else {/* 3 */
530                                p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
531                                p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
532                        }
533                }
534        }
535        else { /* ±âÁ¸ ÀüÀÚ */
536                if(pch->pos==0) {
537                        if(!is_full_ch) { /* 4 */
538                                p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
539                                p_get_ch_list(pwin, x+1, y);
540                                p_update_ch(pwin, x+1, y, ' ', FALSE, FALSE);
541                                ret+=1;
542                        }
543                        else { /* 5 */
544                                p_update_ch(pwin, x, y, ch, is_p16, is_full_ch);
545                        }
546                }
547                else {
548                        if(!is_full_ch) { /* 6 */
549                                p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
550                                p_get_ch_list(pwin, x+1, y);
551                                p_update_ch(pwin, x+1, y, ch, is_p16, is_full_ch);
552                                ret+=1;
553                        }
554                        else {
555                                if(pnext->full_ch==0) { /* 7 */
556                                        p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
557                                        p_update_ch(pwin, x+1, y, ch, is_p16, is_full_ch);
558                                }
559                                else { /* 8 */
560                                        p_update_ch(pwin, x, y, ' ', FALSE, FALSE);
561                                        p_update_ch(pwin, x+1, y, ch, is_p16, is_full_ch);
562                                        p_get_ch_list(pwin, x+2, y);
563                                        p_update_ch(pwin, x+2, y, ' ', FALSE, FALSE);
564                                        ret+=1;
565                                }
566                        }
567                       
568                }
569                       
570        }
571       
572        return ret;
573}
574
575
576static void p_insert_ch(tDCC_DefWin *pwin, UINT16 ch, UINT32 opt)
577{
578        int i;
579        //ÇϳªÀÇ char°¡ ÀԷµǾúÀ½.
580        BOOL is_p16=(opt&eDCC_OPT_P16)?TRUE:FALSE;
581        BOOL is_608=(opt&eDCC_OPT_IS608)?TRUE:FALSE;
582        BOOL is_cr=(opt&eDCC_OPT_CH_CR)?TRUE:FALSE;
583        BOOL is_full_ch=(opt&eDCC_OPT_FULL_CH)?TRUE:FALSE;
584        BOOL is_blank; /*±âÁ¸ char°¡ blankÀÎÁö ¿©ºÎ */
585        BOOL is_line_change=FALSE;
586       
587        int max_width;
588        int max_height;
589       
590        tDCC_Line *pline=&pwin->text[pwin->cur_y];
591       
592        if(!pwin->bcreated) {
593                CCPRINT("win_ch", "window is not created\n");
594                return;
595        }
596       
597        CCPRINT("win_chex", "    1.cur pos xy(%d,%d)\n", pwin->cur_x, pwin->cur_y);
598       
599        //debug
600        if(is_cr) {
601                CCPRINT("win_ch", "insert cr\n");
602        }
603        else if(is_p16 && ch>=0x100) { 
604               
605                char buf[3];
606                buf[0]=ch>>8;
607                buf[1]=ch&0xff;
608                buf[2]=0;
609               
610                CCPRINT("win_ch", "0x%x(%s), P16(yes)\n", ch, buf);
611        }
612        else {
613                if(ch) {
614                        CCPRINT("win_ch", "0x%x(%c), P16(no)\n", ch, ch);
615                }
616        }
617       
618        //608ÀÎ °æ¿ì´Â Á» Ưº°ÇÏ°Ô Ã³¸®ÇÔ. Áï, cur_x°ªÀÌ 608 WIDTH º¸´Ù Ŭ °æ¿ì ±× °ªÀÌ °íÁ¤µÊ
619        if(!is_cr) {
620                if(is_608 && pwin->cur_x>=DCC_608_WIN_WIDTH) {
621                        CCPRINT("win_ch", "608 char is ignored because column is over width\n");
622                        return;
623                }
624        }
625       
626        if(pwin->cl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
627                max_width=DCCGrp_GetMaxFontWidth(pwin->pen_attr.s, FALSE);
628        else
629                max_width=DCCGrp_GetMaxFontWidth(pwin->rcvd_pen_attr.s, FALSE);
630       
631        if(pwin->rl || (pwin->pen_attr.s > pwin->rcvd_pen_attr.s))
632                max_height=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
633        else
634                max_height=DCCGrp_GetMaxFontHeight(pwin->rcvd_pen_attr.s);
635       
636        if(is_cr && pwin->cur_y>0 && pline->y==0 && pline->h==0) {
637                //DFX, SPL ÈÄ ¹Ù·Î CRÀÌ µÚµû¸£´Â °æ¿ì cur_y°ªÀÌ À©µµ¿ì Å©±â¸¦ ³Ñ¾î°¥ ¼ö ÀÖÀ½
638                //ÀÌ·± °æ¿ì ¸ÕÀú lineÀ» °è»êÇÏ´Â °ÍÀÌ ³ªÀ» °Í °°À½.
639                p_update_line(pwin, pwin->cur_y);
640        }
641       
642        if(pwin->win_r.h<pline->y+max_height) {
643                /* ÇÑ ÁÙ Å©±â º¸´Ù ÀÛÀº windowÀÏ °æ¿ì, ±×¸®Áö ¾ÊÀ½ */
644                CCPRINT("win_ch", "!! line info is bad(win_h(%d), line_y(%d), line_h(%d)\n",
645                        pwin->win_r.h, pline->y, max_height);
646                return;
647        }
648       
649        if(pwin->win_r.w<max_width) {
650                /* width°¡ ¾ÆÁÖ ÀÛÀ» °æ¿ì ±×¸®Áö ¾ÊÀ½ */
651                CCPRINT("win_chex", "width is very small(%d<%d)\n", pwin->win_r.w, max_width);
652                return;
653        }
654       
655        if(!is_608) //708ÀÎ °æ¿ì
656        {               
657                if(pwin->cur_x>=MAX_NUM_COL ||
658                        p_get_cur_xpos(pwin)+max_width>pwin->win_r.w ||
659                        is_cr)
660                {
661                        //ccº¸´Ù Å« °æ¿ì, window¸¦ ³Ñ¾î°¡´Â °æ¿ì, CRÀÎ °æ¿ì ÁٹٲÞÀ» ÇÑ´Ù.
662                        is_line_change=TRUE;
663                        pwin->cur_x=0;
664                        CCPRINT("win_chex", "line is changed..row(%d) lineyh(%d,%d) winh(%d)\n",
665                                pwin->cur_y, pline->y, pline->h, pwin->win_r.h);
666
667                        if(pline->y+pline->h+max_height>pwin->win_r.h) {
668                                //ÁٹٲÞÀ» ÇÏ·Á´Ï±î °ø°£ÀÌ ºÎÁ·ÇÑ °æ¿ì -> scrollÀ» ÇØ¾ß ÇÔ.
669                                int scroll_h=pwin->text[0].h; 
670                                if(scroll_h==0) scroll_h=DCCGrp_GetMaxFontHeight(pwin->pen_attr.s);
671                               
672                                CCPRINT("win_chex", "scroll is required..liney(%d) lineh(%d) winh(%d)\n",
673                                        pline->y, pline->h, pwin->win_r.h);
674                               
675                                for(i=0; i<pwin->cur_y; i++) {
676                                        memcpy(&pwin->text[i], &pwin->text[i+1], sizeof(pwin->text[i]));
677                                        pwin->text[i].y-=scroll_h;
678                                }
679                                memset(&pwin->text[i], 0, sizeof(pwin->text[i]));
680                               
681                                if(pwin->v) { //visibleÀÎ °æ¿ì¸¸ ±×¸°´Ù.
682                                        //scroll up/down
683                                        //»ç¶óÁú(ù¹ø°) lineÀÇ ³ôÀ̸¦ scroll up/down ÇÔ.
684                                        if(pwin->win_attr.sd==eDCC_D_TPTOBT) {
685                                                CCPRINT("win_chex", "p_scroll_down\n");
686                                                DCCGrp_ScrollDown(
687                                                        pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, pwin->win_r.h-scroll_h, 
688                                                        scroll_h, p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
689                                                DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y, pwin->win_r.w, scroll_h,
690                                                        p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
691                                        }
692                                        else {
693                                                CCPRINT("win_chex", "p_scroll_up\n");
694                                                DCCGrp_ScrollUp(pwin->win_r.x, pwin->win_r.y+scroll_h, 
695                                                        pwin->win_r.w, pwin->win_r.h-scroll_h, scroll_h,
696                                                        p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
697                                                DCCGrp_DrawBox(pwin->win_r.x, pwin->win_r.y+pwin->win_r.h-scroll_h, 
698                                                        pwin->win_r.w, scroll_h, p_get_color(pwin->win_attr.fc, pwin->win_attr.fo));
699                                        }
700                                }
701                        }
702                        else {
703                                pwin->cur_y++; //´Ü¼øÈ÷ ÁٹٲÞÇÔ.
704                               
705#if DEL_LINE_BEFORE_WRITING
706                                //ÁٹٲÞÇÒ ¶§ ¹öÆÛ¸¦ Áö¿ö¾ß ÇÏ´Â °æ¿ì..justificationÀÌ center, right´Â Áö¿ö¾ß ÇÔ.
707                                if(pwin->win_attr.j!=eDCC_J_LEFT) {
708                                        memset(&pwin->text[pwin->cur_y], 0, sizeof(pwin->text[pwin->cur_y]));
709                                        if(pwin->v) //visibleÀÎ °æ¿ì¸¸ ±×¸°´Ù.
710                                                p_draw_win_line(pwin, pwin->cur_y, TRUE);
711                                }
712                        }
713#endif
714                }
715        }
716
717#if 0   
718        is_blank=pwin->text[pwin->cur_y].str[pwin->cur_x].ch==0?TRUE:FALSE;
719#else
720        is_blank=TRUE;
721#endif
722
723        if(!is_cr)
724                pwin->cur_x+=p_update_ch_ex(pwin, pwin->cur_x, pwin->cur_y, ch, is_p16, is_full_ch);
725       
726        //line ¾÷µ¥ÀÌÆ®         
727        if(p_update_line(pwin, pwin->cur_y)==1) {
728                //lineÀÇ ³ôÀÌ°¡ º¯°æµÇ¾úÀ¸¹Ç·Î lineÀ» ´Ù½Ã ±×·Á¾ß ÇÔ.
729                if(pwin->v && !is_cr) 
730                        p_draw_win_line(pwin, pwin->cur_y, TRUE);
731        }       
732        //left´Â ±ÛÀÚ¸¸ Âï°í, ÀÌ¿Ü´Â ÇÑ ÁÙ Àüü¸¦ ´Ù½Ã ±×·Á¾ß ÇÔ.
733        //608ÀÎ °æ¿ì´Â ¹«Á¶°Ç µ¤¾î ¾¸
734        else if(is_608 || (pwin->win_attr.j==eDCC_J_LEFT && is_blank))  {
735                if(pwin->v && !is_cr) 
736                        p_draw_cur_win_ch(pwin, FALSE);
737        } 
738        else {
739                if(pwin->v && !is_cr) 
740                        p_draw_win_line(pwin, pwin->cur_y, TRUE);
741        }
742       
743        //if(!is_line_change) pwin->cur_x++;
744        if(!is_cr) pwin->cur_x++;
745               
746        CCPRINT("win_chex", "    cur pos xy(%d,%d)\n", pwin->cur_x, pwin->cur_y);
747       
748}
749
750
751static void p_erase_ch(tDCC_DefWin *pwin)
752{
753        //backspace 󸮿ë
754        int i;
755       
756        CCPRINT("ch1", "p_erase_ch\n");
757       
758        p_update_line(pwin, pwin->cur_y);
759        p_draw_cur_win_ch(pwin, TRUE);
760       
761        if(pwin->cur_x==0) {
762                if(pwin->cur_y==0) return;
763               
764                for(i=0; pwin->text[--pwin->cur_y].str[i].ch; i++)
765                        pwin->cur_x++;
766               
767                if(pwin->cur_x>0) pwin->cur_x--;
768               
769        }
770        else {
771                pwin->cur_x--;
772        }
773       
774        p_update_line(pwin, pwin->cur_y);
775       
776        p_draw_cur_win_ch(pwin, TRUE);
777}
778
779
780#if 0
781__Draw_LV2_Func__()
782#endif
783 
784
785static void p_draw_win(tDCC_DefWin *pwin, BOOL draw_bg, BOOL draw_fg, BOOL draw_trp)
786{
787        //°ãÄ¡´Â window°¡ ÀÖ´ÂÁö È®ÀÎÇÏ¿© ÀÖÀ¸¸é ±× window¸¦ ´Ù½Ã ±×·ÁÁà¾ß ÇÔ.
788        int i;
789
790        p_draw_win_base(pwin, draw_bg, draw_fg, draw_trp);
791       
792        for(i=0; i<pwin->num_overlap_win; i++) {
793                p_draw_win_base(&p_dfw[pwin->overlap_win[i]], TRUE, TRUE, draw_trp);
794        }
795}
796
797
798static void p_draw_all_win()
799{
800        int i;
801       
802        for(i=INFO(num_win_list)-1; i>=0; i--) {
803                p_draw_win_base(&p_dfw[INFO(win_list)[i]], TRUE, TRUE, FALSE);
804        }
805}
806
807
808static void p_draw_flash_wins()
809{
810        /* comment
811                flash´Â overlapµÇ´Â winÀÌ ¾ø´Â window¿¡¼­¸¸ µ¿À۵ȴÙ.
812        */
813#if ENABLE_FLASH
814        int i, idx;
815       
816        for(i=INFO(num_win_list)-1; i>=0; i--) {
817               
818                idx=INFO(win_list)[i];
819               
820#if FLASHING_ONLY_FRONT_WIN
821                if(p_dfw[idx].num_overlap_win>0) continue;
822#endif
823               
824                if(p_dfw[idx].win_attr.fo==eDCC_O_FLASH)
825                        p_draw_win_base(&p_dfw[idx], TRUE, TRUE, FALSE);
826                else if(p_dfw[idx].pen_attr.fo==eDCC_O_FLASH || p_dfw[idx].pen_attr.bo==eDCC_O_FLASH)
827                        p_draw_win_base(&p_dfw[idx], FALSE, TRUE, FALSE);
828        }
829#endif
830       
831}
832
833
834#if 0
835___Update_Attr__()
836#endif
837
838
839//win
840tDCC_DefWin *DCCWin_GetWin(int wid)
841{
842        return &p_dfw[wid];
843}
844
845
846void DCCWin_DrawWin(int wid, BOOL draw_bg, BOOL draw_fg)
847{
848        p_draw_win(&p_dfw[wid], draw_bg, draw_fg, FALSE);
849}
850
851
852void DCCWin_EraseWin(int wid)
853{
854        p_draw_win(&p_dfw[wid], FALSE, FALSE, TRUE);
855}
856
857
858void DCCWin_DrawAllWins()
859{
860        p_draw_all_win();
861}
862
863
864void DCCWin_DrawFlashWins()
865{
866        p_draw_flash_wins();
867}
868
869
870void DCCWin_ResetWin(int wid)
871{
872        memset(&p_dfw[wid], 0, sizeof(p_dfw[wid]));
873}
874
875
876void DCCWin_ResetTextPos(int wid)
877{
878        memset(&p_dfw[wid].text, 0, sizeof(p_dfw[wid].text));
879        p_dfw[wid].cur_x=0;
880        p_dfw[wid].cur_y=0;
881}
882
883
884void DCCWin_ResetTextOnly(int wid)
885{
886        memset(&p_dfw[wid].text, 0, sizeof(p_dfw[wid].text));
887}
888
889
890void DCCWin_ResetAllWins(BOOL berase_screen)
891{
892        memset(p_dfw, 0, sizeof(p_dfw));
893       
894        if(berase_screen) DCCGrp_ClearScreen();
895}
896
897
898void DCCWin_UpdateWinRect(int wid)
899{
900        //pen size ¼³Á¤
901        p_set_pen_attr(&p_dfw[wid].pen_attr); //ÁÂÇ¥ °è»êÀ» Çϱâ Àü pen attrÀ» ¸ÕÀú ¼³Á¤ÇÔ.
902        p_get_win_rect(&p_dfw[wid], FALSE);
903}
904
905BOOL DCCWin_CheckWinRect(int wid)
906{
907        p_set_pen_attr(&p_dfw[wid].pen_attr); //ÁÂÇ¥ °è»êÀ» Çϱâ Àü pen attrÀ» ¸ÕÀú ¼³Á¤ÇÔ.
908        return p_get_win_rect(&p_dfw[wid], TRUE);
909}
910
911
912void DCCWin_UpdateWinAttr()
913{
914        //win overlap ÀçÁ¡°Ë.
915        p_update_overlap_win();
916}
917
918
919//line
920void DCCWin_EraseCurLine(int wid, BOOL is_der)
921{
922        int i;
923        tDCC_DefWin *pwin=DCCWin_GetWin(wid);
924       
925        if(is_der) {
926                //608ÀÇ der ¸ðµå·Î µ¿ÀÛ, ÇöÀçºÎÅÍ ³¡±îÁö¸¦ ´Ù Áö¿ò
927                for(i=pwin->cur_x; i<MAX_NUM_COL+1; i++)
928                        memset(&pwin->text[pwin->cur_y].str[i], 0, sizeof(pwin->text[pwin->cur_y].str[i]));
929                //line ¾÷µ¥ÀÌÆ®
930                p_draw_win_line(pwin, pwin->cur_y, TRUE);
931        }
932        else {
933                //line Àüü¸¦ Áö¿ì°í cursor¸¦ ¸¸ ¾Õ À§Ä¡·Î º¯°æ
934                memset(&pwin->text[pwin->cur_y].str, 0, sizeof(pwin->text[pwin->cur_y].str));
935                pwin->cur_x=0;
936                p_draw_win_line(pwin, pwin->cur_y, TRUE);
937        }
938       
939}
940
941
942void DCCWin_FillTrpToLine(int wid)
943{
944        //ÇöÀç row¿¡¼­ ÇØ´ç col±îÁö NULLÀÌ ÀÖÀ¸¸é ' '·Î ä¿ö³ÖÀ½
945        int i;
946        tDCC_DefWin *pwin=DCCWin_GetWin(wid);
947       
948        for(i=0; i<pwin->cur_x; i++) {
949                if(pwin->text[pwin->cur_y].str[i].ch==0)
950                        p_update_ch(pwin, i, pwin->cur_y, DCC_TRP_CODE, FALSE, FALSE);
951        }
952}
953
954
955//char
956void DCCWin_InsertCh(int wid, UINT16 ch, UINT32 opt)
957{
958        p_insert_ch(&p_dfw[wid], ch, opt);
959       
960}
961
962
963void DCCWin_EraseCh(int wid)
964{
965        p_erase_ch(&p_dfw[wid]);
966}
967
968
969void DCCWin_UpdateLine(int wid, int row)
970{
971        tDCC_DefWin *pwin=DCCWin_GetWin(wid);
972       
973        p_update_line(pwin, row);
974}
975
976
977void DCCWin_ToggleFlashFlag()
978{
979        INFO(flash_fg)=INFO(flash_fg)?FALSE:TRUE;
980}
981
982
983void DCCWin_SetUserPos(int x, int y)
984{
985        INFO(user_posx)=x;
986        INFO(user_posy)=y;
987}
988
Note: See TracBrowser for help on using the repository browser.