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


#ifndef INCLUDE_DRAW_BUF_H
#define INCLUDE_DRAW_BUF_H
#print "[include ]\n"
 
#ifndef INCLUDE_KOLIBRI_H
#include "../lib/kolibri.h"
#endif
 
dword buf_data=0;
 
 
struct DrawBufer {
	dword bufx, bufy, bufw, bufh;
	dword fill_color;
 
	bool Init();
	void Show();
	void Fill();
	void DrawBar();
	void WriteText();
	void PutPixel();
	void AlignCenter();
	void AlignRight();
	void IncreaseBufSize();
};
 
char draw_buf_not_enaught_ram[] = 
"'DrawBufer needs more memory than currenly available.
Application could be unstable.
 
Requested size: %i Mb
Free RAM: %i Mb' -E";
 
bool DrawBufer::Init(dword i_bufx, i_bufy, i_bufw, i_bufh)
{
	bufx = i_bufx;
	bufy = i_bufy;
	bufw = i_bufw; 
	bufh = i_bufh;
	if (buf_data) buf_data = free(buf_data);
	IncreaseBufSize();
	if (!buf_data) return false;
	ESDWORD[buf_data] = bufw;
	ESDWORD[buf_data+4] = bufh;
	return true;
}
 
void DrawBufer::Fill(dword start_pointer, i_fill_color)
{
	dword i;
	dword max_i = bufw * bufh * 4 + buf_data + 8;
	fill_color = i_fill_color;
	MEMSETD(buf_data+start_pointer+8, max_i-buf_data-start_pointer-8/4, fill_color);
}
 
void DrawBufer::DrawBar(dword x, y, w, h, color)
{
	dword i, j;
	if (y + h >= bufh) IncreaseBufSize();
	for (j=0; j
		for (i = y+j*bufw+x<<2+8+buf_data; i
			ESDWORD[i] = color;
		}
	}
}
 
void DrawBufer::WriteText(dword x, y, byte fontType, dword color, str_offset)
{
	#define BUGFIX_32000 32000
	dword ydiv=0;
	dword reserve_data_1, reserve_data_2;
	dword new_buf_offset;
	if (y + 30 >= bufh) IncreaseBufSize();
	if (y < BUGFIX_32000) {
		WriteBufText(x, y, fontType, color, str_offset, buf_data);
	}
	else {
		ydiv = y / BUGFIX_32000 * BUGFIX_32000;
		y -= ydiv;
		new_buf_offset = ydiv * bufw * 4 + buf_data;
 
		reserve_data_1 = ESDWORD[new_buf_offset];
		reserve_data_2 = ESDWORD[new_buf_offset+4];
 
		ESDWORD[new_buf_offset] = bufw;
		ESDWORD[new_buf_offset+4] = bufh - y;
		WriteBufText(x, y, fontType, color, str_offset, new_buf_offset);
 
		ESDWORD[new_buf_offset] = reserve_data_1;
		ESDWORD[new_buf_offset+4] = reserve_data_2;
	}
}
 
void DrawBufer::PutPixel(dword x, y, color)
{
	dword pos = y*bufw+x*4+8+buf_data;
	ESDWORD[pos] = color;
}
 
void DrawBufer::AlignRight(dword x,y,w,h, content_width)
{
	dword i, j, l;
	dword content_left = w - content_width / 2;
	for (j=0; j
	{
		for (i=j*w+w-x*4, l=j*w+content_width+x*4; (i>=j*w+content_left*4) && (l>=j*w*4); i-=4, l-=4)
		{
			ESDWORD[buf_data+8+i] >< ESDWORD[buf_data+8+l];
		}
	}
}
 
void DrawBufer::AlignCenter(dword x,y,w,h, content_width)
{
	dword i, j, l;
	dword content_left = w - content_width / 2;
	for (j=0; j
	{
		for (i=j*w+content_width+content_left*4, l=j*w+content_width+x*4; (i>=j*w+content_left*4) && (l>=j*w*4); i-=4, l-=4)
		{
			ESDWORD[buf_data+8+i] >< ESDWORD[buf_data+8+l];
		}
	}
}
 
/*
void DrawBufer::Zoom2x(int zoom)
{
	int i, s;
	dword point_x, max_i, zline_w, s_inc;
 
	point_x = 0;
	max_i = bufw * bufh * 4 + buf_data+8;
	s_inc = zoom * 4;
	zline_w = zbufw * 4;
 
	for (i=buf_data+8, s=zbuf_data+8; i
		ESDWORD[s] = ESDWORD[i];
		ESDWORD[s+4] = ESDWORD[i];
		ESDWORD[s+zline_w] = ESDWORD[i];
		ESDWORD[s+zline_w+4] = ESDWORD[i];
		if (zoom==3)
		{
			ESDWORD[s+8] = ESDWORD[i];
			ESDWORD[zline_w+s+8] = ESDWORD[i];
			ESDWORD[zline_w*2+s] = ESDWORD[i];
			ESDWORD[zline_w*2+s+4] = ESDWORD[i];
			ESDWORD[zline_w*2+s+8] = ESDWORD[i];
		}
 
		point_x++;
		if (point_x >= bufw) 
		{
			s += zoom - 1 * zline_w;
			point_x = 0;
		}
	}
}
*/
 
 
void DrawBufer::Show()
{
	PutPaletteImage(buf_data+8, bufw, bufh, bufx, bufy, 32, 0);	
}
 
void DrawBufer::IncreaseBufSize()
{
	static dword alloc_counter;
	static dword bufh_initial;
	dword alloc_size;
	dword free_ram_size;
	char error_str[256];
 
	if (!buf_data) {
		alloc_counter = 1;
		bufh_initial = bufh;
		alloc_size = bufw * bufh * 4 + 8;
		buf_data = malloc(alloc_size);
	}
	else {
		alloc_counter++;
		bufh = bufh_initial * alloc_counter;
		alloc_size = bufw * bufh * 4 + 8;
		buf_data = realloc(buf_data, alloc_size);
		Fill(alloc_counter - 1 * bufw * bufh_initial * 4 + 8, fill_color);
	}
 
	free_ram_size = GetFreeRAM() * 1024;
	if (alloc_size >= free_ram_size) {
		sprintf(#error_str, #draw_buf_not_enaught_ram, alloc_size/1048576, free_ram_size/1048576);
		notify(#error_str);
	}
}
 
 
 
#endif

Rev 7764	Rev 7866
1	#ifndef INCLUDE_DRAW_BUF_H	1	#ifndef INCLUDE_DRAW_BUF_H
2	#define INCLUDE_DRAW_BUF_H	2	#define INCLUDE_DRAW_BUF_H
3	#print "[include ]\n"	3	#print "[include ]\n"
4		4
5	#ifndef INCLUDE_KOLIBRI_H	5	#ifndef INCLUDE_KOLIBRI_H
6	#include "../lib/kolibri.h"	6	#include "../lib/kolibri.h"
7	#endif	7	#endif
8		8
9	dword buf_data;	9	dword buf_data=0;
10		10
11		11
12	struct DrawBufer {	12	struct DrawBufer {
13	dword bufx, bufy, bufw, bufh;	13	dword bufx, bufy, bufw, bufh;
14	dword fill_color;	14	dword fill_color;
15		15
16	bool Init();	16	bool Init();
17	void Show();	17	void Show();
18	void Fill();	18	void Fill();
19	void DrawBar();	19	void DrawBar();
20	void WriteText();	20	void WriteText();
21	void PutPixel();	21	void PutPixel();
22	void AlignCenter();	22	void AlignCenter();
23	void AlignRight();	23	void AlignRight();
24	void IncreaseBufSize();	24	void IncreaseBufSize();
25	};	25	};
26		26
27	char draw_buf_not_enaught_ram[] =	27	char draw_buf_not_enaught_ram[] =
28	"'DrawBufer needs more memory than currenly available.	28	"'DrawBufer needs more memory than currenly available.
29	Application could be unstable.	29	Application could be unstable.
30		30
31	Requested size: %i Mb	31	Requested size: %i Mb
32	Free RAM: %i Mb' -E";	32	Free RAM: %i Mb' -E";
33		33
34	bool DrawBufer::Init(dword i_bufx, i_bufy, i_bufw, i_bufh)	34	bool DrawBufer::Init(dword i_bufx, i_bufy, i_bufw, i_bufh)
35	{	35	{
36	bufx = i_bufx;	36	bufx = i_bufx;
37	bufy = i_bufy;	37	bufy = i_bufy;
38	bufw = i_bufw;	38	bufw = i_bufw;
39	bufh = i_bufh;	39	bufh = i_bufh;
40	buf_data = free(buf_data);	40	if (buf_data) buf_data = free(buf_data);
41	IncreaseBufSize();	41	IncreaseBufSize();
42	if (!buf_data) return false;	42	if (!buf_data) return false;
43	ESDWORD[buf_data] = bufw;	43	ESDWORD[buf_data] = bufw;
44	ESDWORD[buf_data+4] = bufh;	44	ESDWORD[buf_data+4] = bufh;
45	return true;	45	return true;
46	}	46	}
47		47
48	void DrawBufer::Fill(dword start_pointer, i_fill_color)	48	void DrawBufer::Fill(dword start_pointer, i_fill_color)
49	{	49	{
50	dword i;	50	dword i;
51	dword max_i = bufw * bufh * 4 + buf_data + 8;	51	dword max_i = bufw * bufh * 4 + buf_data + 8;
52	fill_color = i_fill_color;	52	fill_color = i_fill_color;
53	MEMSETD(buf_data+start_pointer+8, max_i-buf_data-start_pointer-8/4, fill_color);	53	MEMSETD(buf_data+start_pointer+8, max_i-buf_data-start_pointer-8/4, fill_color);
54	}	54	}
55		55
56	void DrawBufer::DrawBar(dword x, y, w, h, color)	56	void DrawBufer::DrawBar(dword x, y, w, h, color)
57	{	57	{
58	dword i, j;	58	dword i, j;
59	if (y + h >= bufh) IncreaseBufSize();	59	if (y + h >= bufh) IncreaseBufSize();
60	for (j=0; j	60	for (j=0; j
61	for (i = y+j*bufw+x<<2+8+buf_data; i	61	for (i = y+j*bufw+x<<2+8+buf_data; i
62	ESDWORD[i] = color;	62	ESDWORD[i] = color;
63	}	63	}
64	}	64	}
65	}	65	}
66		66
67	void DrawBufer::WriteText(dword x, y, byte fontType, dword color, str_offset)	67	void DrawBufer::WriteText(dword x, y, byte fontType, dword color, str_offset)
68	{	68	{
69	#define BUGFIX_32000 32000	69	#define BUGFIX_32000 32000
70	dword ydiv=0;	70	dword ydiv=0;
71	dword reserve_data_1, reserve_data_2;	71	dword reserve_data_1, reserve_data_2;
72	dword new_buf_offset;	72	dword new_buf_offset;
73	if (y + 30 >= bufh) IncreaseBufSize();	73	if (y + 30 >= bufh) IncreaseBufSize();
74	if (y < BUGFIX_32000) {	74	if (y < BUGFIX_32000) {
75	WriteBufText(x, y, fontType, color, str_offset, buf_data);	75	WriteBufText(x, y, fontType, color, str_offset, buf_data);
76	}	76	}
77	else {	77	else {
78	ydiv = y / BUGFIX_32000 * BUGFIX_32000;	78	ydiv = y / BUGFIX_32000 * BUGFIX_32000;
79	y -= ydiv;	79	y -= ydiv;
80	new_buf_offset = ydiv * bufw * 4 + buf_data;	80	new_buf_offset = ydiv * bufw * 4 + buf_data;
81		81
82	reserve_data_1 = ESDWORD[new_buf_offset];	82	reserve_data_1 = ESDWORD[new_buf_offset];
83	reserve_data_2 = ESDWORD[new_buf_offset+4];	83	reserve_data_2 = ESDWORD[new_buf_offset+4];
84		84
85	ESDWORD[new_buf_offset] = bufw;	85	ESDWORD[new_buf_offset] = bufw;
86	ESDWORD[new_buf_offset+4] = bufh - y;	86	ESDWORD[new_buf_offset+4] = bufh - y;
87	WriteBufText(x, y, fontType, color, str_offset, new_buf_offset);	87	WriteBufText(x, y, fontType, color, str_offset, new_buf_offset);
88		88
89	ESDWORD[new_buf_offset] = reserve_data_1;	89	ESDWORD[new_buf_offset] = reserve_data_1;
90	ESDWORD[new_buf_offset+4] = reserve_data_2;	90	ESDWORD[new_buf_offset+4] = reserve_data_2;
91	}	91	}
92	}	92	}
93		93
94	void DrawBufer::PutPixel(dword x, y, color)	94	void DrawBufer::PutPixel(dword x, y, color)
95	{	95	{
96	dword pos = ybufw+x4+8+buf_data;	96	dword pos = ybufw+x4+8+buf_data;
97	ESDWORD[pos] = color;	97	ESDWORD[pos] = color;
98	}	98	}
99		99
100	void DrawBufer::AlignRight(dword x,y,w,h, content_width)	100	void DrawBufer::AlignRight(dword x,y,w,h, content_width)
101	{	101	{
102	dword i, j, l;	102	dword i, j, l;
103	dword content_left = w - content_width / 2;	103	dword content_left = w - content_width / 2;
104	for (j=0; j	104	for (j=0; j
105	{	105	{
106	for (i=jw+w-x4, l=jw+content_width+x4; (i>=jw+content_left4) && (l>=jw4); i-=4, l-=4)	106	for (i=jw+w-x4, l=jw+content_width+x4; (i>=jw+content_left4) && (l>=jw4); i-=4, l-=4)
107	{	107	{
108	ESDWORD[buf_data+8+i] >< ESDWORD[buf_data+8+l];	108	ESDWORD[buf_data+8+i] >< ESDWORD[buf_data+8+l];
109	}	109	}
110	}	110	}
111	}	111	}
112		112
113	void DrawBufer::AlignCenter(dword x,y,w,h, content_width)	113	void DrawBufer::AlignCenter(dword x,y,w,h, content_width)
114	{	114	{
115	dword i, j, l;	115	dword i, j, l;
116	dword content_left = w - content_width / 2;	116	dword content_left = w - content_width / 2;
117	for (j=0; j	117	for (j=0; j
118	{	118	{
119	for (i=jw+content_width+content_left4, l=jw+content_width+x4; (i>=jw+content_left4) && (l>=jw4); i-=4, l-=4)	119	for (i=jw+content_width+content_left4, l=jw+content_width+x4; (i>=jw+content_left4) && (l>=jw4); i-=4, l-=4)
120	{	120	{
121	ESDWORD[buf_data+8+i] >< ESDWORD[buf_data+8+l];	121	ESDWORD[buf_data+8+i] >< ESDWORD[buf_data+8+l];
122	}	122	}
123	}	123	}
124	}	124	}
125		125
126	/*	126	/*
127	void DrawBufer::Zoom2x(int zoom)	127	void DrawBufer::Zoom2x(int zoom)
128	{	128	{
129	int i, s;	129	int i, s;
130	dword point_x, max_i, zline_w, s_inc;	130	dword point_x, max_i, zline_w, s_inc;
131		131
132	point_x = 0;	132	point_x = 0;
133	max_i = bufw * bufh * 4 + buf_data+8;	133	max_i = bufw * bufh * 4 + buf_data+8;
134	s_inc = zoom * 4;	134	s_inc = zoom * 4;
135	zline_w = zbufw * 4;	135	zline_w = zbufw * 4;
136		136
137	for (i=buf_data+8, s=zbuf_data+8; i	137	for (i=buf_data+8, s=zbuf_data+8; i
138	ESDWORD[s] = ESDWORD[i];	138	ESDWORD[s] = ESDWORD[i];
139	ESDWORD[s+4] = ESDWORD[i];	139	ESDWORD[s+4] = ESDWORD[i];
140	ESDWORD[s+zline_w] = ESDWORD[i];	140	ESDWORD[s+zline_w] = ESDWORD[i];
141	ESDWORD[s+zline_w+4] = ESDWORD[i];	141	ESDWORD[s+zline_w+4] = ESDWORD[i];
142	if (zoom==3)	142	if (zoom==3)
143	{	143	{
144	ESDWORD[s+8] = ESDWORD[i];	144	ESDWORD[s+8] = ESDWORD[i];
145	ESDWORD[zline_w+s+8] = ESDWORD[i];	145	ESDWORD[zline_w+s+8] = ESDWORD[i];
146	ESDWORD[zline_w*2+s] = ESDWORD[i];	146	ESDWORD[zline_w*2+s] = ESDWORD[i];
147	ESDWORD[zline_w*2+s+4] = ESDWORD[i];	147	ESDWORD[zline_w*2+s+4] = ESDWORD[i];
148	ESDWORD[zline_w*2+s+8] = ESDWORD[i];	148	ESDWORD[zline_w*2+s+8] = ESDWORD[i];
149	}	149	}
150		150
151	point_x++;	151	point_x++;
152	if (point_x >= bufw)	152	if (point_x >= bufw)
153	{	153	{
154	s += zoom - 1 * zline_w;	154	s += zoom - 1 * zline_w;
155	point_x = 0;	155	point_x = 0;
156	}	156	}
157	}	157	}
158	}	158	}
159	*/	159	*/
160		160
161		161
162	void DrawBufer::Show()	162	void DrawBufer::Show()
163	{	163	{
164	PutPaletteImage(buf_data+8, bufw, bufh, bufx, bufy, 32, 0);	164	PutPaletteImage(buf_data+8, bufw, bufh, bufx, bufy, 32, 0);
165	}	165	}
166		166
167	void DrawBufer::IncreaseBufSize()	167	void DrawBufer::IncreaseBufSize()
168	{	168	{
169	static dword alloc_counter;	169	static dword alloc_counter;
170	static dword bufh_initial;	170	static dword bufh_initial;
171	dword alloc_size;	171	dword alloc_size;
172	dword free_ram_size;	172	dword free_ram_size;
173	char error_str[256];	173	char error_str[256];
174		174
175	if (!buf_data) {	175	if (!buf_data) {
176	alloc_counter = 1;	176	alloc_counter = 1;
177	bufh_initial = bufh;	177	bufh_initial = bufh;
178	alloc_size = bufw * bufh * 4 + 8;	178	alloc_size = bufw * bufh * 4 + 8;
179	buf_data = malloc(alloc_size);	179	buf_data = malloc(alloc_size);
180	}	180	}
181	else {	181	else {
182	alloc_counter++;	182	alloc_counter++;
183	bufh = bufh_initial * alloc_counter;	183	bufh = bufh_initial * alloc_counter;
184	alloc_size = bufw * bufh * 4 + 8;	184	alloc_size = bufw * bufh * 4 + 8;
185	buf_data = realloc(buf_data, alloc_size);	185	buf_data = realloc(buf_data, alloc_size);
186	Fill(alloc_counter - 1 * bufw * bufh_initial * 4 + 8, fill_color);	186	Fill(alloc_counter - 1 * bufw * bufh_initial * 4 + 8, fill_color);
187	}	187	}
188		188
189	free_ram_size = GetFreeRAM() * 1024;	189	free_ram_size = GetFreeRAM() * 1024;
190	if (alloc_size >= free_ram_size) {	190	if (alloc_size >= free_ram_size) {
191	sprintf(#error_str, #draw_buf_not_enaught_ram, alloc_size/1048576, free_ram_size/1048576);	191	sprintf(#error_str, #draw_buf_not_enaught_ram, alloc_size/1048576, free_ram_size/1048576);
192	notify(#error_str);	192	notify(#error_str);
193	}	193	}
194	}	194	}
195		195
196		196
197		197
198	#endif	198	#endif

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/draw_buf.h @ 7889 – Rev 7764 → 7866