WebSVN – Kolibri OS – Diff – /programs/cmm/lib/font.h


#ifndef INCLUDE_FONT_H
#define INCLUDE_FONT_H
 
#ifndef INCLUDE_MATH_H
#include "../lib/math.h"
#endif
 
#ifndef INCLUDE_IO_H
#include "../lib/io.h"
#endif
 
 
#define CP866 0
#define ANSI   1
 
:struct __SIZE
{
	word width,height;
	signed offset_x,offset_y;
	float offset_i,w_italic;
	byte text;
	byte TMP_WEIGHT;
};
:struct FONT
{
	__SIZE size;
	byte width,height,offsetLine,r,g,b,weight,italic;
	byte encoding;
	dword color;
	dword file_size;
	dword buffer;
	dword buffer_size;
	word block;
	dword data;
	dword begin;
	dword size_file;
	byte load(...);
	byte symbol(word x;byte s;dword c);
	byte symbol_size(byte s);
	dword prepare(word x,y;dword text1);
	void show(word x,y);
	byte textcenter(word x,y,w,h;dword txt);
	dword getsize(dword text1);
	dword textarea(word x,y;dword text,c);
	byte changeSIZE();
	void PixelRGB(word x,y);
	dword GetPixel(word x,y);
	dword tmp_y,tmp_height,tmp_x;
	byte no_bg_copy;
	dword bg_color;
};
FONT font = 0;
 
:dword FONT::GetPixel(word x,y)
{
	dword tmp;
	tmp = y*size.width*3;
	tmp += x*3;
	tmp += buffer;
	r = DSBYTE[tmp];
	tmp++;
	g = DSBYTE[tmp];
	tmp++;
	b = DSBYTE[tmp];
}
:void FONT::PixelRGB(dword x,y)
{
	dword tmp;
	tmp = y*size.width*3;
	tmp += x*3;
	tmp += buffer;
 
	DSBYTE[tmp] = r;
	tmp++;
	DSBYTE[tmp] = g;
	tmp++;
	DSBYTE[tmp] = b;
}
:byte FONT::changeSIZE()
{
	dword TMP_DATA;
	dword ofs;
	byte s;
	IF(size.text<9) size.text = 8;
	s = size.text-8;
	data = begin;
	TMP_DATA = data;
	TMP_DATA +=s*4;
	ofs = DSDWORD[TMP_DATA];
	IF(ofs==-1)return false;
	data += ofs;
	data += 156;
	TMP_DATA = data;
	file_size = DSDWORD[TMP_DATA];
	TMP_DATA += file_size;
	TMP_DATA--;
	height = DSBYTE[TMP_DATA];
	TMP_DATA--;
	width =  DSBYTE[TMP_DATA];
	block = math.ceil(height*width/32);
	return true;
}
:proc_info Form_SELF_FONTS;
:byte FONT::textcenter(word x,y,w,h;dword txt)
{
	getsize(txt);
	EDX = w/2;
	ECX = size.width/2;
	EDX -= ECX;
	x += EDX;
	return text(x,y,txt);
}
:dword FONT::getsize(dword text1)
{
	size.height = size.width = 0;
	size.offset_x = size.offset_y = -1;
	IF(size.text)IF(!changeSIZE())return 0;
	WHILE(DSBYTE[text1])
	{
		symbol_size(DSBYTE[text1]);
		text1++;
	}
	$neg size.offset_y
	$neg size.offset_x
	size.height++;
	size.height += size.offset_y;
	size.width += size.offset_x;
	size.width++;
	IF(italic)
	{
		size.w_italic = size.height/3;
		size.offset_i = size.w_italic/size.height;
		size.width += size.w_italic;
		size.w_italic = -size.w_italic;
	}
	return size.width;
}
:byte FONT::symbol_size(byte s)
{
        dword xi,yi;
        dword tmp,_;
        dword iii;
        byte rw=0;
		byte X;
		size.TMP_WEIGHT = math.ceil(size.text/17);
        IF(s==32)
		{
			size.width += width/4;
			IF(weight) size.width+=size.TMP_WEIGHT;
			return;
		}
		IF(s==9)
		{
			size.width += width;
			IF(weight) size.width+=size.TMP_WEIGHT;
			return;
		}
		IF(!encoding){
			IF(s>=128)&&(s<=175)s+=64;
			ELSE IF(s>=224)&&(s<=239)s+=16;
			ELSE IF(s==241)s=184; //yo
			ELSE IF(s==240)s=168; //YO
		}
        yi = 0;
        iii = 0;
        tmp = 4*block*s;
        tmp +=data;
        while(yi
        {
                xi = 0;
                WHILE(xi
                {
                        IF(iii%32) _ >>= 1;
						ELSE
						{
                                tmp += 4;
                                _ = DSDWORD[tmp];
                        }
                        IF(_&1)
						{
							IF(xi>rw)rw=xi;
							IF(size.height
							IF(size.offset_y<0)size.offset_y = yi;
							ELSE IF(yi
							IF(!X) X = xi;
							ELSE IF(X>xi)X = xi;
						}
                        xi++;
                        iii++;
                }
                yi++;
        }
		size.width += rw;
		IF(weight) size.width+=size.TMP_WEIGHT;
		IF(s=='_') size.width--;
		IF(size.offset_x<0)size.offset_x = X;
}
:dword FONT::prepare(word x,y;dword text1)
{
	signed len=0;
	dword c;
	word _tmp_h;
	c = color;
	IF(!text1)return false;
	IF(size.text)IF(!changeSIZE())return false;
	GetProcessInfo(#Form_SELF_FONTS, SelfInfo); 
	IF(y>Form_SELF_FONTS.cheight) return false;
	IF(x>Form_SELF_FONTS.cwidth) return false;
	AX = c;
	r = AL;
	g = AH;
	c>>=16;
	AX = c;
	b = AL;
	getsize(text1);
	y -= size.offset_y;
	tmp_y = y;
	
	EDX = size.width*size.height*3;
	IF(!buffer_size)
	{
		buffer_size = EDX;
		buffer = malloc(buffer_size);
	}
	ELSE IF(buffer_size
	{
		buffer_size = EDX;
		buffer = realloc(buffer,buffer_size);
	}
	IF (no_bg_copy)
	{
		EBX = bg_color;
		EDI = buffer;
		EAX = buffer_size+EDI;
		WHILE (EDI
		{
			ESDWORD[EDI] = EBX;
			$add edi,3
		}
	}
	ELSE CopyScreen(buffer,x+Form_SELF_FONTS.left+5,y+Form_SELF_FONTS.top+GetSkinHeight(),size.width,size.height);
	len = size.offset_x;
	WHILE(DSBYTE[text1])
	{
		IF(DSBYTE[text1]=='_') len--;
		len+=symbol(len,DSBYTE[text1]);
		IF(weight)len+=math.ceil(size.text/17);
		text1++;
	}
	IF (no_bg_copy) && (!color) SmoothFont(buffer, size.width, size.height);
	return len;
}
:void FONT::show(word x,y)
{
	_PutImage(x,y,size.width,size.height,buffer);
}
inline fastcall dword b24(EBX) { return DSDWORD[EBX] << 8; }
:void SmoothFont(dword image, w, h)
{
	byte rr,gg,bb;
	dword i,line_w,to, pixel;
	line_w = w * 3;
	to = w*h*3 + image - line_w - 3;
	for (i = image; i < to; i+=3)	{
		if (i-image%line_w +3 == line_w) continue;
		if (b24(i)==0x000000) && (b24(i+3)!=0x000000) && (b24(i+line_w)!=0x000000) && (b24(i+3+line_w)==0x000000)
		{ 
			ShadowImage(i+3, 1, 1, 2);
			ShadowImage(i+line_w, 1, 1, 2);
		}
		else if (b24(i)!=0x000000) && (b24(i+3)==0x000000) && (b24(i+line_w)==0x000000) && (b24(i+3+line_w)!=0x000000)
		{
			ShadowImage(i, 1, 1, 2);
			ShadowImage(i+3+line_w, 1, 1, 2);
		}
	}
}
:dword FONT::textarea(word x,y;dword text1,c;byte size)
{
	
}
 
:byte FONT::symbol(signed x;byte s)
{
        dword xi,yi;
        dword tmp,_;
        dword iii;
		float ital = -size.w_italic;
		dword ___x;
		word TMP;
		byte _TMP_WEIGHT;
        byte rw=0;
        IF(s==32)return width/4;
		IF(s==9)return width;
		IF(!encoding)
		{
			IF(s>=128)&&(s<=175)s+=64;
			ELSE IF(s>=224)&&(s<=239)s+=16;
			ELSE IF(s==241)s=184; //yo
			ELSE IF(s==240)s=168; //YO
		}
        yi = 0;
        iii = 0;
        tmp = 4*block*s;
        tmp +=data;
        while(yi
        {
                xi = 0;
				TMP = size.offset_y+yi;
                while(xi
                {
					IF(iii%32) _ >>= 1;
					ELSE
					{
							tmp += 4;
							_ = DSDWORD[tmp];
					}
					if(_&1)
					{
							IF(xi>rw)rw=xi;
							___x = x+xi;
							IF(italic)___x+=math.ceil(ital);
							if(___x
							{
								PixelRGB(___x,TMP);
								_TMP_WEIGHT = size.TMP_WEIGHT;
								WHILE(_TMP_WEIGHT)
								{
									IF(weight) PixelRGB(___x+_TMP_WEIGHT,TMP);
									_TMP_WEIGHT--;
								}
							}
					}
					xi++;
					iii++;
                }
                yi++;
				IF(italic) ital-=size.offset_i;
        }
        return rw;
}
:byte FONT::load(dword path)
{
	dword tmp;
	buffer_size = 0;
	IF(data)free(data);
	if (!io.readKPACK(path))
	{
		debug("Error while loading font: ");
		debugln(path);
		return false;
	}
	begin = tmp = data = io.buffer_data;
	size_file = io.FILES_SIZE;
	tmp +=size_file;
	tmp--;
	height = DSBYTE[tmp];
	tmp--;
	width = DSBYTE[tmp];
	block = math.ceil(height*width/32);
	return true;
}
 
#endif
>
>
>
>
>
>
>
>
>
>
>
>

Rev 5776	Rev 5778
1	#ifndef INCLUDE_FONT_H	1	#ifndef INCLUDE_FONT_H
2	#define INCLUDE_FONT_H	2	#define INCLUDE_FONT_H
3		3
4	#ifndef INCLUDE_MATH_H	4	#ifndef INCLUDE_MATH_H
5	#include "../lib/math.h"	5	#include "../lib/math.h"
6	#endif	6	#endif
7		7
8	#ifndef INCLUDE_IO_H	8	#ifndef INCLUDE_IO_H
9	#include "../lib/io.h"	9	#include "../lib/io.h"
10	#endif	10	#endif
11		11
12		12
13	#define CP866 0	13	#define CP866 0
14	#define ANSI 1	14	#define ANSI 1
15		15
16	:struct __SIZE	16	:struct __SIZE
17	{	17	{
18	word width,height;	18	word width,height;
19	signed offset_x,offset_y;	19	signed offset_x,offset_y;
20	float offset_i,w_italic;	20	float offset_i,w_italic;
21	byte text;	21	byte text;
22	byte TMP_WEIGHT;	22	byte TMP_WEIGHT;
23	};	23	};
24	:struct FONT	24	:struct FONT
25	{	25	{
26	__SIZE size;	26	__SIZE size;
27	byte width,height,offsetLine,r,g,b,weight,italic;	27	byte width,height,offsetLine,r,g,b,weight,italic;
28	byte encoding;	28	byte encoding;
29	dword color;	29	dword color;
30	dword file_size;	30	dword file_size;
31	dword buffer;	31	dword buffer;
32	dword buffer_size;	32	dword buffer_size;
33	word block;	33	word block;
34	dword data;	34	dword data;
35	dword begin;	35	dword begin;
36	dword size_file;	36	dword size_file;
37	byte load(...);	37	byte load(...);
38	byte symbol(word x;byte s;dword c);	38	byte symbol(word x;byte s;dword c);
39	byte symbol_size(byte s);	39	byte symbol_size(byte s);
40	dword prepare(word x,y;dword text1);	40	dword prepare(word x,y;dword text1);
41	void show(word x,y);	41	void show(word x,y);
42	byte textcenter(word x,y,w,h;dword txt);	42	byte textcenter(word x,y,w,h;dword txt);
43	dword getsize(dword text1);	43	dword getsize(dword text1);
44	dword textarea(word x,y;dword text,c);	44	dword textarea(word x,y;dword text,c);
45	byte changeSIZE();	45	byte changeSIZE();
46	void PixelRGB(word x,y);	46	void PixelRGB(word x,y);
47	dword GetPixel(word x,y);	47	dword GetPixel(word x,y);
48	dword tmp_y,tmp_height,tmp_x;	48	dword tmp_y,tmp_height,tmp_x;
49	byte no_bg_copy;	49	byte no_bg_copy;
50	dword bg_color;	50	dword bg_color;
51	};	51	};
52	FONT font = 0;	52	FONT font = 0;
53		53
54	:dword FONT::GetPixel(word x,y)	54	:dword FONT::GetPixel(word x,y)
55	{	55	{
56	dword tmp;	56	dword tmp;
57	tmp = ysize.width3;	57	tmp = ysize.width3;
58	tmp += x*3;	58	tmp += x*3;
59	tmp += buffer;	59	tmp += buffer;
60	r = DSBYTE[tmp];	60	r = DSBYTE[tmp];
61	tmp++;	61	tmp++;
62	g = DSBYTE[tmp];	62	g = DSBYTE[tmp];
63	tmp++;	63	tmp++;
64	b = DSBYTE[tmp];	64	b = DSBYTE[tmp];
65	}	65	}
66	:void FONT::PixelRGB(dword x,y)	66	:void FONT::PixelRGB(dword x,y)
67	{	67	{
68	dword tmp;	68	dword tmp;
69	tmp = ysize.width3;	69	tmp = ysize.width3;
70	tmp += x*3;	70	tmp += x*3;
71	tmp += buffer;	71	tmp += buffer;
72		72
73	DSBYTE[tmp] = r;	73	DSBYTE[tmp] = r;
74	tmp++;	74	tmp++;
75	DSBYTE[tmp] = g;	75	DSBYTE[tmp] = g;
76	tmp++;	76	tmp++;
77	DSBYTE[tmp] = b;	77	DSBYTE[tmp] = b;
78	}	78	}
79	:byte FONT::changeSIZE()	79	:byte FONT::changeSIZE()
80	{	80	{
81	dword TMP_DATA;	81	dword TMP_DATA;
82	dword ofs;	82	dword ofs;
83	byte s;	83	byte s;
84	IF(size.text<9) size.text = 8;	84	IF(size.text<9) size.text = 8;
85	s = size.text-8;	85	s = size.text-8;
86	data = begin;	86	data = begin;
87	TMP_DATA = data;	87	TMP_DATA = data;
88	TMP_DATA +=s*4;	88	TMP_DATA +=s*4;
89	ofs = DSDWORD[TMP_DATA];	89	ofs = DSDWORD[TMP_DATA];
90	IF(ofs==-1)return false;	90	IF(ofs==-1)return false;
91	data += ofs;	91	data += ofs;
92	data += 156;	92	data += 156;
93	TMP_DATA = data;	93	TMP_DATA = data;
94	file_size = DSDWORD[TMP_DATA];	94	file_size = DSDWORD[TMP_DATA];
95	TMP_DATA += file_size;	95	TMP_DATA += file_size;
96	TMP_DATA--;	96	TMP_DATA--;
97	height = DSBYTE[TMP_DATA];	97	height = DSBYTE[TMP_DATA];
98	TMP_DATA--;	98	TMP_DATA--;
99	width = DSBYTE[TMP_DATA];	99	width = DSBYTE[TMP_DATA];
100	block = math.ceil(height*width/32);	100	block = math.ceil(height*width/32);
101	return true;	101	return true;
102	}	102	}
103	:proc_info Form_SELF_FONTS;	103	:proc_info Form_SELF_FONTS;
104	:byte FONT::textcenter(word x,y,w,h;dword txt)	104	:byte FONT::textcenter(word x,y,w,h;dword txt)
105	{	105	{
106	getsize(txt);	106	getsize(txt);
107	EDX = w/2;	107	EDX = w/2;
108	ECX = size.width/2;	108	ECX = size.width/2;
109	EDX -= ECX;	109	EDX -= ECX;
110	x += EDX;	110	x += EDX;
111	return text(x,y,txt);	111	return text(x,y,txt);
112	}	112	}
113	:dword FONT::getsize(dword text1)	113	:dword FONT::getsize(dword text1)
114	{	114	{
115	size.height = size.width = 0;	115	size.height = size.width = 0;
116	size.offset_x = size.offset_y = -1;	116	size.offset_x = size.offset_y = -1;
117	IF(size.text)IF(!changeSIZE())return 0;	117	IF(size.text)IF(!changeSIZE())return 0;
118	WHILE(DSBYTE[text1])	118	WHILE(DSBYTE[text1])
119	{	119	{
120	symbol_size(DSBYTE[text1]);	120	symbol_size(DSBYTE[text1]);
121	text1++;	121	text1++;
122	}	122	}
123	$neg size.offset_y	123	$neg size.offset_y
124	$neg size.offset_x	124	$neg size.offset_x
125	size.height++;	125	size.height++;
126	size.height += size.offset_y;	126	size.height += size.offset_y;
127	size.width += size.offset_x;	127	size.width += size.offset_x;
128	size.width++;	128	size.width++;
129	IF(italic)	129	IF(italic)
130	{	130	{
131	size.w_italic = size.height/3;	131	size.w_italic = size.height/3;
132	size.offset_i = size.w_italic/size.height;	132	size.offset_i = size.w_italic/size.height;
133	size.width += size.w_italic;	133	size.width += size.w_italic;
134	size.w_italic = -size.w_italic;	134	size.w_italic = -size.w_italic;
135	}	135	}
136	return size.width;	136	return size.width;
137	}	137	}
138	:byte FONT::symbol_size(byte s)	138	:byte FONT::symbol_size(byte s)
139	{	139	{
140	dword xi,yi;	140	dword xi,yi;
141	dword tmp,_;	141	dword tmp,_;
142	dword iii;	142	dword iii;
143	byte rw=0;	143	byte rw=0;
144	byte X;	144	byte X;
145	size.TMP_WEIGHT = math.ceil(size.text/17);	145	size.TMP_WEIGHT = math.ceil(size.text/17);
146	IF(s==32)	146	IF(s==32)
147	{	147	{
148	size.width += width/4;	148	size.width += width/4;
149	IF(weight) size.width+=size.TMP_WEIGHT;	149	IF(weight) size.width+=size.TMP_WEIGHT;
150	return;	150	return;
151	}	151	}
152	IF(s==9)	152	IF(s==9)
153	{	153	{
154	size.width += width;	154	size.width += width;
155	IF(weight) size.width+=size.TMP_WEIGHT;	155	IF(weight) size.width+=size.TMP_WEIGHT;
156	return;	156	return;
157	}	157	}
158	IF(!encoding){	158	IF(!encoding){
159	IF(s>=128)&&(s<=175)s+=64;	159	IF(s>=128)&&(s<=175)s+=64;
160	ELSE IF(s>=224)&&(s<=239)s+=16;	160	ELSE IF(s>=224)&&(s<=239)s+=16;
-		161	ELSE IF(s==241)s=184; //yo
-		162	ELSE IF(s==240)s=168; //YO
161	}	163	}
162	yi = 0;	164	yi = 0;
163	iii = 0;	165	iii = 0;
164	tmp = 4blocks;	166	tmp = 4blocks;
165	tmp +=data;	167	tmp +=data;
166	while(yi	168	while(yi
167	{	169	{
168	xi = 0;	170	xi = 0;
169	WHILE(xi	171	WHILE(xi
170	{	172	{
171	IF(iii%32) _ >>= 1;	173	IF(iii%32) _ >>= 1;
172	ELSE	174	ELSE
173	{	175	{
174	tmp += 4;	176	tmp += 4;
175	_ = DSDWORD[tmp];	177	_ = DSDWORD[tmp];
176	}	178	}
177	IF(_&1)	179	IF(_&1)
178	{	180	{
179	IF(xi>rw)rw=xi;	181	IF(xi>rw)rw=xi;
180	IF(size.height	182	IF(size.height
181	IF(size.offset_y<0)size.offset_y = yi;	183	IF(size.offset_y<0)size.offset_y = yi;
182	ELSE IF(yi	184	ELSE IF(yi
183	IF(!X) X = xi;	185	IF(!X) X = xi;
184	ELSE IF(X>xi)X = xi;	186	ELSE IF(X>xi)X = xi;
185	}	187	}
186	xi++;	188	xi++;
187	iii++;	189	iii++;
188	}	190	}
189	yi++;	191	yi++;
190	}	192	}
191	size.width += rw;	193	size.width += rw;
192	IF(weight) size.width+=size.TMP_WEIGHT;	194	IF(weight) size.width+=size.TMP_WEIGHT;
193	IF(s=='_') size.width--;	195	IF(s=='_') size.width--;
194	IF(size.offset_x<0)size.offset_x = X;	196	IF(size.offset_x<0)size.offset_x = X;
195	}	197	}
196	:dword FONT::prepare(word x,y;dword text1)	198	:dword FONT::prepare(word x,y;dword text1)
197	{	199	{
198	signed len=0;	200	signed len=0;
199	dword c;	201	dword c;
200	word _tmp_h;	202	word _tmp_h;
201	c = color;	203	c = color;
202	IF(!text1)return false;	204	IF(!text1)return false;
203	IF(size.text)IF(!changeSIZE())return false;	205	IF(size.text)IF(!changeSIZE())return false;
204	GetProcessInfo(#Form_SELF_FONTS, SelfInfo);	206	GetProcessInfo(#Form_SELF_FONTS, SelfInfo);
205	IF(y>Form_SELF_FONTS.cheight) return false;	207	IF(y>Form_SELF_FONTS.cheight) return false;
206	IF(x>Form_SELF_FONTS.cwidth) return false;	208	IF(x>Form_SELF_FONTS.cwidth) return false;
207	AX = c;	209	AX = c;
208	r = AL;	210	r = AL;
209	g = AH;	211	g = AH;
210	c>>=16;	212	c>>=16;
211	AX = c;	213	AX = c;
212	b = AL;	214	b = AL;
213	getsize(text1);	215	getsize(text1);
214	y -= size.offset_y;	216	y -= size.offset_y;
215	tmp_y = y;	217	tmp_y = y;
216		218
217	EDX = size.widthsize.height3;	219	EDX = size.widthsize.height3;
218	IF(!buffer_size)	220	IF(!buffer_size)
219	{	221	{
220	buffer_size = EDX;	222	buffer_size = EDX;
221	buffer = malloc(buffer_size);	223	buffer = malloc(buffer_size);
222	}	224	}
223	ELSE IF(buffer_size	225	ELSE IF(buffer_size
224	{	226	{
225	buffer_size = EDX;	227	buffer_size = EDX;
226	buffer = realloc(buffer,buffer_size);	228	buffer = realloc(buffer,buffer_size);
227	}	229	}
228	IF (no_bg_copy)	230	IF (no_bg_copy)
229	{	231	{
230	EBX = bg_color;	232	EBX = bg_color;
231	EDI = buffer;	233	EDI = buffer;
232	EAX = buffer_size+EDI;	234	EAX = buffer_size+EDI;
233	WHILE (EDI	235	WHILE (EDI
234	{	236	{
235	ESDWORD[EDI] = EBX;	237	ESDWORD[EDI] = EBX;
236	$add edi,3	238	$add edi,3
237	}	239	}
238	}	240	}
239	ELSE CopyScreen(buffer,x+Form_SELF_FONTS.left+5,y+Form_SELF_FONTS.top+GetSkinHeight(),size.width,size.height);	241	ELSE CopyScreen(buffer,x+Form_SELF_FONTS.left+5,y+Form_SELF_FONTS.top+GetSkinHeight(),size.width,size.height);
240	len = size.offset_x;	242	len = size.offset_x;
241	WHILE(DSBYTE[text1])	243	WHILE(DSBYTE[text1])
242	{	244	{
243	IF(DSBYTE[text1]=='_') len--;	245	IF(DSBYTE[text1]=='_') len--;
244	len+=symbol(len,DSBYTE[text1]);	246	len+=symbol(len,DSBYTE[text1]);
245	IF(weight)len+=math.ceil(size.text/17);	247	IF(weight)len+=math.ceil(size.text/17);
246	text1++;	248	text1++;
247	}	249	}
248	IF (no_bg_copy) && (!color) SmoothFont(buffer, size.width, size.height);	250	IF (no_bg_copy) && (!color) SmoothFont(buffer, size.width, size.height);
249	return len;	251	return len;
250	}	252	}
251	:void FONT::show(word x,y)	253	:void FONT::show(word x,y)
252	{	254	{
253	_PutImage(x,y,size.width,size.height,buffer);	255	_PutImage(x,y,size.width,size.height,buffer);
254	}	256	}
255	inline fastcall dword b24(EBX) { return DSDWORD[EBX] << 8; }	257	inline fastcall dword b24(EBX) { return DSDWORD[EBX] << 8; }
256	:void SmoothFont(dword image, w, h)	258	:void SmoothFont(dword image, w, h)
257	{	259	{
258	byte rr,gg,bb;	260	byte rr,gg,bb;
259	dword i,line_w,to, pixel;	261	dword i,line_w,to, pixel;
260	line_w = w * 3;	262	line_w = w * 3;
261	to = wh3 + image - line_w - 3;	263	to = wh3 + image - line_w - 3;
262	for (i = image; i < to; i+=3) {	264	for (i = image; i < to; i+=3) {
263	if (i-image%line_w +3 == line_w) continue;	265	if (i-image%line_w +3 == line_w) continue;
264	if (b24(i)==0x000000) && (b24(i+3)!=0x000000) && (b24(i+line_w)!=0x000000) && (b24(i+3+line_w)==0x000000)	266	if (b24(i)==0x000000) && (b24(i+3)!=0x000000) && (b24(i+line_w)!=0x000000) && (b24(i+3+line_w)==0x000000)
265	{	267	{
266	ShadowImage(i+3, 1, 1, 2);	268	ShadowImage(i+3, 1, 1, 2);
267	ShadowImage(i+line_w, 1, 1, 2);	269	ShadowImage(i+line_w, 1, 1, 2);
268	}	270	}
269	else if (b24(i)!=0x000000) && (b24(i+3)==0x000000) && (b24(i+line_w)==0x000000) && (b24(i+3+line_w)!=0x000000)	271	else if (b24(i)!=0x000000) && (b24(i+3)==0x000000) && (b24(i+line_w)==0x000000) && (b24(i+3+line_w)!=0x000000)
270	{	272	{
271	ShadowImage(i, 1, 1, 2);	273	ShadowImage(i, 1, 1, 2);
272	ShadowImage(i+3+line_w, 1, 1, 2);	274	ShadowImage(i+3+line_w, 1, 1, 2);
273	}	275	}
274	}	276	}
275	}	277	}
276	:dword FONT::textarea(word x,y;dword text1,c;byte size)	278	:dword FONT::textarea(word x,y;dword text1,c;byte size)
277	{	279	{
278		280
279	}	281	}
280		282
281	:byte FONT::symbol(signed x;byte s)	283	:byte FONT::symbol(signed x;byte s)
282	{	284	{
283	dword xi,yi;	285	dword xi,yi;
284	dword tmp,_;	286	dword tmp,_;
285	dword iii;	287	dword iii;
286	float ital = -size.w_italic;	288	float ital = -size.w_italic;
287	dword ___x;	289	dword ___x;
288	word TMP;	290	word TMP;
289	byte _TMP_WEIGHT;	291	byte _TMP_WEIGHT;
290	byte rw=0;	292	byte rw=0;
291	IF(s==32)return width/4;	293	IF(s==32)return width/4;
292	IF(s==9)return width;	294	IF(s==9)return width;
293	IF(!encoding)	295	IF(!encoding)
294	{	296	{
295	IF(s>=128)&&(s<=175)s+=64;	297	IF(s>=128)&&(s<=175)s+=64;
296	ELSE IF(s>=224)&&(s<=239)s+=16;	298	ELSE IF(s>=224)&&(s<=239)s+=16;
-		299	ELSE IF(s==241)s=184; //yo
-		300	ELSE IF(s==240)s=168; //YO
297	}	301	}
298	yi = 0;	302	yi = 0;
299	iii = 0;	303	iii = 0;
300	tmp = 4blocks;	304	tmp = 4blocks;
301	tmp +=data;	305	tmp +=data;
302	while(yi	306	while(yi
303	{	307	{
304	xi = 0;	308	xi = 0;
305	TMP = size.offset_y+yi;	309	TMP = size.offset_y+yi;
306	while(xi	310	while(xi
307	{	311	{
308	IF(iii%32) _ >>= 1;	312	IF(iii%32) _ >>= 1;
309	ELSE	313	ELSE
310	{	314	{
311	tmp += 4;	315	tmp += 4;
312	_ = DSDWORD[tmp];	316	_ = DSDWORD[tmp];
313	}	317	}
314	if(_&1)	318	if(_&1)
315	{	319	{
316	IF(xi>rw)rw=xi;	320	IF(xi>rw)rw=xi;
317	___x = x+xi;	321	___x = x+xi;
318	IF(italic)___x+=math.ceil(ital);	322	IF(italic)___x+=math.ceil(ital);
319	if(___x	323	if(___x
320	{	324	{
321	PixelRGB(___x,TMP);	325	PixelRGB(___x,TMP);
322	_TMP_WEIGHT = size.TMP_WEIGHT;	326	_TMP_WEIGHT = size.TMP_WEIGHT;
323	WHILE(_TMP_WEIGHT)	327	WHILE(_TMP_WEIGHT)
324	{	328	{
325	IF(weight) PixelRGB(___x+_TMP_WEIGHT,TMP);	329	IF(weight) PixelRGB(___x+_TMP_WEIGHT,TMP);
326	_TMP_WEIGHT--;	330	_TMP_WEIGHT--;
327	}	331	}
328	}	332	}
329	}	333	}
330	xi++;	334	xi++;
331	iii++;	335	iii++;
332	}	336	}
333	yi++;	337	yi++;
334	IF(italic) ital-=size.offset_i;	338	IF(italic) ital-=size.offset_i;
335	}	339	}
336	return rw;	340	return rw;
337	}	341	}
338	:byte FONT::load(dword path)	342	:byte FONT::load(dword path)
339	{	343	{
340	dword tmp;	344	dword tmp;
341	buffer_size = 0;	345	buffer_size = 0;
342	IF(data)free(data);	346	IF(data)free(data);
343	if (!io.readKPACK(path))	347	if (!io.readKPACK(path))
344	{	348	{
345	debug("Error while loading font: ");	349	debug("Error while loading font: ");
346	debugln(path);	350	debugln(path);
347	return false;	351	return false;
348	}	352	}
349	begin = tmp = data = io.buffer_data;	353	begin = tmp = data = io.buffer_data;
350	size_file = io.FILES_SIZE;	354	size_file = io.FILES_SIZE;
351	tmp +=size_file;	355	tmp +=size_file;
352	tmp--;	356	tmp--;
353	height = DSBYTE[tmp];	357	height = DSBYTE[tmp];
354	tmp--;	358	tmp--;
355	width = DSBYTE[tmp];	359	width = DSBYTE[tmp];
356	block = math.ceil(height*width/32);	360	block = math.ceil(height*width/32);
357	return true;	361	return true;
358	}	362	}
359		363
360	#endif	364	#endif
361	>	365	>
362	>	366	>
363	>	367	>
364	>	368	>
365	>	369	>
366	>	370	>
367	>	371	>
368	>	372	>
369	>	373	>
370	>	374	>
371	>	375	>
372	>	376	>

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/font.h @ 5782 – Rev 5776 → 5778