WebSVN – Kolibri OS – Diff – /programs/cmm/iconedit/colors_mas.h


#define MAX_CELL_SIZE 256
 
//////////////////////////////////////////////////////////////////////////////////////
//                                                                                  //
//                                  DRAW PIXEL                                      //
//                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////
 
//The 'draw[]' is the array which holds the states should we draw a pixel or not.
//Is need to decrease redraw when using some tools like line, rectangle and selection.
 
struct _pixel_state
{
	unsigned image_rows, image_columns;
	bool draw[MAX_CELL_SIZE*MAX_CELL_SIZE];
	void set_drawable_state();
	bool is_drawable();
	void reset_and_set_all_drawable();
	void set_sizes();
} pixel_state;
 
void _pixel_state::set_drawable_state(int _r, _c, _state)
{
	draw[image_columns*_r + _c] = _state;
}
 
bool _pixel_state::is_drawable(int _r, _c)
{
	return draw[image_columns*_r + _c];
}
 
void _pixel_state::reset_and_set_all_drawable()
{
	int i;
	for (i = 0; i < image_columns*image_rows; i++) draw[i]=true;
}
 
void _pixel_state::set_sizes(dword _r, _c)
{
	image_rows = _r;
	image_columns = _c;
}
 
//////////////////////////////////////////////////////////////////////////////////////
//                                                                                  //
//                                      IMAGE                                       //
//                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////
 
//This stucture determines basic actions that can be done with image (icon).
 
struct _image
{
	unsigned rows, columns;
	dword mas[MAX_CELL_SIZE*MAX_CELL_SIZE];
	dword img;
	_pixel_state pixel_state;
	void create();
	void set_pixel();
	void draw_line();
	void fill();
	void set_image();
	dword get_pixel();
	dword get_image();
	void move();
};
 
void _image::create(int _rows, _columns)
{
	int i;
	rows = _rows;
	columns = _columns;
	for (i = 0; i < columns*rows; i++) mas[i]=0xBFCAD2;
	pixel_state.set_sizes(rows, columns);
}
 
void _image::set_pixel(int _r, _c, _color)
{
	mas[columns*_r + _c] = _color;
}
 
void _image::draw_line(int x1, int y1, int x2, int y2, dword color) {
	int dx, dy, signX, signY, error, error2;
 
	dx = x2 - x1;
 
	if (dx < 0)
		dx = -dx;
   
	dy = y2 - y1;
 
	if (dy < 0)
		dy = -dy;
   
	if (x1 < x2)
		signX = 1;
	else
		signX = -1;
   
	if (y1 < y2)
		signY = 1;
	else
		signY = -1;
   
	error = dx - dy;
 
	set_pixel(y2, x2, color);
 
	while((x1 != x2) || (y1 != y2)) 
	{
		set_pixel(y1, x1, color);
		
		error2 = error * 2;
 
		if(error2 > calc(-dy)) 
		{
			error -= dy;
			x1 += signX;
		}
 
		if(error2 < dx) 
		{
			error += dx;
			y1 += signY;
		}
	}
}
 
void _image::fill(int _r, _c, _color)
{
	#define MARKED 6
	int r, c, i, restart;
 
	dword old_color = get_pixel(_r, _c);
	set_pixel(_r, _c, MARKED);
 
	do {
		restart=false;	
		for (r = 0; r < rows; r++)
			for (c = 0; c < columns; c++)
			{
				IF (get_pixel(r,c) != old_color) continue;
				IF (get_pixel(r,c) == MARKED) continue;
				
				IF (c>0)               && (get_pixel(r,c-1) == MARKED) set_pixel(r,c,MARKED);
				IF (r>0)               && (get_pixel(r-1,c) == MARKED) set_pixel(r,c,MARKED);
				IF (c
				IF (r
				
				IF (get_pixel(r,c)==MARKED) restart=true;
			}
	}while(restart);
 
	for (i=0; i
			IF (mas[i]==MARKED) mas[i] = _color;
}
 
dword _image::get_pixel(int _r, _c)
{
	return mas[columns*_r + _c];
}
 
void _image::set_image(dword _inbuf)
{
	dword i;
	for (i = 0; i < columns*rows; i++;) 
	{
		// mas[i] = ESDWORD[i*4+_inbuf] & 0x00FFFFFF; //for x32 bit color
		mas[i] = ESDWORD[i*3+_inbuf] & 0xFFFFFF;
	}
}
 
dword _image::get_image()
{
	int r=0, c=0;
	dword i;
 
	free(img);
	i = img = malloc(rows*columns*3);
 
	for (r = 0; r < rows; r++)
		for (c = 0; c < columns; c++)
		{
			rgb.DwordToRgb(get_pixel(r,c));
			ESBYTE[i] = rgb.b;
			ESBYTE[i+1] = rgb.g;
			ESBYTE[i+2] = rgb.r;
			i += 3;
		}
	return img;
}
 
enum {
	MOVE_LEFT,
	MOVE_RIGHT,
	MOVE_UP,
	MOVE_DOWN,
	FLIP_VER,
	FLIP_HOR,
	ROTE
};
void _image::move(int _direction)
{
	int r, c;
	dword first_element_data;
 
	switch(_direction)
	{
		case MOVE_LEFT:
				for (r = 0; r < rows; r++)
				{
					first_element_data = get_pixel(r, 0);
					for (c = 0; c < columns-1; c++) set_pixel(r, c, get_pixel(r, c+1));
					set_pixel(r, columns-1, first_element_data);
				}
				break;
		case MOVE_RIGHT:
				for (r = 0; r < rows; r++)
				{
					first_element_data = get_pixel(r, columns-1);
					for (c = columns-1; c > 0; c--) set_pixel(r, c, get_pixel(r, c-1));
					set_pixel(r, 0, first_element_data);
				}	
				break;	
		case MOVE_UP:
				for (c = 0; c < columns; c++)
				{
					first_element_data = get_pixel(0, c);
					for (r = 0; r < rows-1; r++) set_pixel(r, c, get_pixel(r+1, c));
					set_pixel(rows-1, c, first_element_data);
				}	
				break;
		case MOVE_DOWN:
				for (c = 0; c < columns; c++)
				{
					first_element_data = get_pixel(rows-1, c);
					for (r = rows-1; r > 0; r--) set_pixel(r, c, get_pixel(r-1, c));
					set_pixel(0, c, first_element_data);
				}
				break;
		case FLIP_HOR:
				for (r = 0; r < rows; r++)
					for (c = 0; c < columns/2; c++) {
						first_element_data = get_pixel(r, c);
						set_pixel(r, c, get_pixel(r, columns-c-1));
						set_pixel(r, columns-c-1, first_element_data);
					}
				break;
		case FLIP_VER:
				for (c = 0; c < columns; c++)
					for (r = 0; r < rows/2; r++) {
						first_element_data = get_pixel(r, c);
						set_pixel(r, c, get_pixel(rows-r-1, c));
						set_pixel(rows-r-1, c, first_element_data);
					}
				break;	
	}
}

Rev 7257	Rev 7259
1	#define MAX_CELL_SIZE 256	1	#define MAX_CELL_SIZE 256
2		2
3	//////////////////////////////////////////////////////////////////////////////////////	3	//////////////////////////////////////////////////////////////////////////////////////
4	// //	4	// //
5	// DRAW PIXEL //	5	// DRAW PIXEL //
6	// //	6	// //
7	//////////////////////////////////////////////////////////////////////////////////////	7	//////////////////////////////////////////////////////////////////////////////////////
8		8
9	//The 'draw[]' in the array which holds the states should we draw a pixel or not.	9	//The 'draw[]' is the array which holds the states should we draw a pixel or not.
10	//Is need to decrese redraw when using some tools like line, rectangle and selection.	10	//Is need to decrease redraw when using some tools like line, rectangle and selection.
11		11
12	struct _pixel_state	12	struct _pixel_state
13	{	13	{
14	unsigned image_rows, image_columns;	14	unsigned image_rows, image_columns;
15	bool draw[MAX_CELL_SIZE*MAX_CELL_SIZE];	15	bool draw[MAX_CELL_SIZE*MAX_CELL_SIZE];
16	void set_drawable_state();	16	void set_drawable_state();
17	bool is_drawable();	17	bool is_drawable();
18	void reset_and_set_all_drawable();	18	void reset_and_set_all_drawable();
19	void set_sizes();	19	void set_sizes();
20	} pixel_state;	20	} pixel_state;
21		21
22	void _pixel_state::set_drawable_state(int _r, _c, _state)	22	void _pixel_state::set_drawable_state(int _r, _c, _state)
23	{	23	{
24	draw[image_columns*_r + _c] = _state;	24	draw[image_columns*_r + _c] = _state;
25	}	25	}
26		26
27	bool _pixel_state::is_drawable(int _r, _c)	27	bool _pixel_state::is_drawable(int _r, _c)
28	{	28	{
29	return draw[image_columns*_r + _c];	29	return draw[image_columns*_r + _c];
30	}	30	}
31		31
32	void _pixel_state::reset_and_set_all_drawable()	32	void _pixel_state::reset_and_set_all_drawable()
33	{	33	{
34	int i;	34	int i;
35	for (i = 0; i < image_columns*image_rows; i++) draw[i]=true;	35	for (i = 0; i < image_columns*image_rows; i++) draw[i]=true;
36	}	36	}
37		37
38	void _pixel_state::set_sizes(dword _r, _c)	38	void _pixel_state::set_sizes(dword _r, _c)
39	{	39	{
40	image_rows = _r;	40	image_rows = _r;
41	image_columns = _c;	41	image_columns = _c;
42	}	42	}
43		43
44	//////////////////////////////////////////////////////////////////////////////////////	44	//////////////////////////////////////////////////////////////////////////////////////
45	// //	45	// //
46	// IMAGE //	46	// IMAGE //
47	// //	47	// //
48	//////////////////////////////////////////////////////////////////////////////////////	48	//////////////////////////////////////////////////////////////////////////////////////
49		49
50	//This stucture determines basic actions that can be done with image (icon).	50	//This stucture determines basic actions that can be done with image (icon).
51		51
52	struct _image	52	struct _image
53	{	53	{
54	unsigned rows, columns;	54	unsigned rows, columns;
55	dword mas[MAX_CELL_SIZE*MAX_CELL_SIZE];	55	dword mas[MAX_CELL_SIZE*MAX_CELL_SIZE];
56	dword img;	56	dword img;
57	_pixel_state pixel_state;	57	_pixel_state pixel_state;
58	void create();	58	void create();
59	void set_pixel();	59	void set_pixel();
60	void draw_line();	60	void draw_line();
61	void fill();	61	void fill();
62	void set_image();	62	void set_image();
63	dword get_pixel();	63	dword get_pixel();
64	dword get_image();	64	dword get_image();
65	void move();	65	void move();
66	};	66	};
67		67
68	void _image::create(int _rows, _columns)	68	void _image::create(int _rows, _columns)
69	{	69	{
70	int i;	70	int i;
71	rows = _rows;	71	rows = _rows;
72	columns = _columns;	72	columns = _columns;
73	for (i = 0; i < columns*rows; i++) mas[i]=0xBFCAD2;	73	for (i = 0; i < columns*rows; i++) mas[i]=0xBFCAD2;
74	pixel_state.set_sizes(rows, columns);	74	pixel_state.set_sizes(rows, columns);
75	}	75	}
76		76
77	void _image::set_pixel(int _r, _c, _color)	77	void _image::set_pixel(int _r, _c, _color)
78	{	78	{
79	mas[columns*_r + _c] = _color;	79	mas[columns*_r + _c] = _color;
80	}	80	}
81		81
82	void _image::draw_line(int x1, int y1, int x2, int y2, dword color) {	82	void _image::draw_line(int x1, int y1, int x2, int y2, dword color) {
83	int dx, dy, signX, signY, error, error2;	83	int dx, dy, signX, signY, error, error2;
84		84
85	dx = x2 - x1;	85	dx = x2 - x1;
86		86
87	if (dx < 0)	87	if (dx < 0)
88	dx = -dx;	88	dx = -dx;
89		89
90	dy = y2 - y1;	90	dy = y2 - y1;
91		91
92	if (dy < 0)	92	if (dy < 0)
93	dy = -dy;	93	dy = -dy;
94		94
95	if (x1 < x2)	95	if (x1 < x2)
96	signX = 1;	96	signX = 1;
97	else	97	else
98	signX = -1;	98	signX = -1;
99		99
100	if (y1 < y2)	100	if (y1 < y2)
101	signY = 1;	101	signY = 1;
102	else	102	else
103	signY = -1;	103	signY = -1;
104		104
105	error = dx - dy;	105	error = dx - dy;
106		106
107	set_pixel(y2, x2, color);	107	set_pixel(y2, x2, color);
108		108
109	while((x1 != x2) \|\| (y1 != y2))	109	while((x1 != x2) \|\| (y1 != y2))
110	{	110	{
111	set_pixel(y1, x1, color);	111	set_pixel(y1, x1, color);
112		112
113	error2 = error * 2;	113	error2 = error * 2;
114		114
115	if(error2 > calc(-dy))	115	if(error2 > calc(-dy))
116	{	116	{
117	error -= dy;	117	error -= dy;
118	x1 += signX;	118	x1 += signX;
119	}	119	}
120		120
121	if(error2 < dx)	121	if(error2 < dx)
122	{	122	{
123	error += dx;	123	error += dx;
124	y1 += signY;	124	y1 += signY;
125	}	125	}
126	}	126	}
127	}	127	}
128		128
129	void _image::fill(int _r, _c, _color)	129	void _image::fill(int _r, _c, _color)
130	{	130	{
131	#define MARKED 6	131	#define MARKED 6
132	int r, c, i, restart;	132	int r, c, i, restart;
133		133
134	dword old_color = get_pixel(_r, _c);	134	dword old_color = get_pixel(_r, _c);
135	set_pixel(_r, _c, MARKED);	135	set_pixel(_r, _c, MARKED);
136		136
137	do {	137	do {
138	restart=false;	138	restart=false;
139	for (r = 0; r < rows; r++)	139	for (r = 0; r < rows; r++)
140	for (c = 0; c < columns; c++)	140	for (c = 0; c < columns; c++)
141	{	141	{
142	IF (get_pixel(r,c) != old_color) continue;	142	IF (get_pixel(r,c) != old_color) continue;
143	IF (get_pixel(r,c) == MARKED) continue;	143	IF (get_pixel(r,c) == MARKED) continue;
144		144
145	IF (c>0) && (get_pixel(r,c-1) == MARKED) set_pixel(r,c,MARKED);	145	IF (c>0) && (get_pixel(r,c-1) == MARKED) set_pixel(r,c,MARKED);
146	IF (r>0) && (get_pixel(r-1,c) == MARKED) set_pixel(r,c,MARKED);	146	IF (r>0) && (get_pixel(r-1,c) == MARKED) set_pixel(r,c,MARKED);
147	IF (c	147	IF (c
148	IF (r	148	IF (r
149		149
150	IF (get_pixel(r,c)==MARKED) restart=true;	150	IF (get_pixel(r,c)==MARKED) restart=true;
151	}	151	}
152	}while(restart);	152	}while(restart);
153		153
154	for (i=0; i	154	for (i=0; i
155	IF (mas[i]==MARKED) mas[i] = _color;	155	IF (mas[i]==MARKED) mas[i] = _color;
156	}	156	}
157		157
158	dword _image::get_pixel(int _r, _c)	158	dword _image::get_pixel(int _r, _c)
159	{	159	{
160	return mas[columns*_r + _c];	160	return mas[columns*_r + _c];
161	}	161	}
162		162
163	void _image::set_image(dword _inbuf)	163	void _image::set_image(dword _inbuf)
164	{	164	{
165	dword i;	165	dword i;
166	for (i = 0; i < columns*rows; i++;)	166	for (i = 0; i < columns*rows; i++;)
167	{	167	{
168	// mas[i] = ESDWORD[i*4+_inbuf] & 0x00FFFFFF; //for x32 bit color	168	// mas[i] = ESDWORD[i*4+_inbuf] & 0x00FFFFFF; //for x32 bit color
169	mas[i] = ESDWORD[i*3+_inbuf] & 0xFFFFFF;	169	mas[i] = ESDWORD[i*3+_inbuf] & 0xFFFFFF;
170	}	170	}
171	}	171	}
172		172
173	dword _image::get_image()	173	dword _image::get_image()
174	{	174	{
175	int r=0, c=0;	175	int r=0, c=0;
176	dword i;	176	dword i;
177		177
178	free(img);	178	free(img);
179	i = img = malloc(rowscolumns3);	179	i = img = malloc(rowscolumns3);
180		180
181	for (r = 0; r < rows; r++)	181	for (r = 0; r < rows; r++)
182	for (c = 0; c < columns; c++)	182	for (c = 0; c < columns; c++)
183	{	183	{
184	rgb.DwordToRgb(get_pixel(r,c));	184	rgb.DwordToRgb(get_pixel(r,c));
185	ESBYTE[i] = rgb.b;	185	ESBYTE[i] = rgb.b;
186	ESBYTE[i+1] = rgb.g;	186	ESBYTE[i+1] = rgb.g;
187	ESBYTE[i+2] = rgb.r;	187	ESBYTE[i+2] = rgb.r;
188	i += 3;	188	i += 3;
189	}	189	}
190	return img;	190	return img;
191	}	191	}
192		192
193	enum {	193	enum {
194	MOVE_LEFT,	194	MOVE_LEFT,
195	MOVE_RIGHT,	195	MOVE_RIGHT,
196	MOVE_UP,	196	MOVE_UP,
197	MOVE_DOWN,	197	MOVE_DOWN,
198	FLIP_VER,	198	FLIP_VER,
199	FLIP_HOR,	199	FLIP_HOR,
200	ROTE	200	ROTE
201	};	201	};
202	void _image::move(int _direction)	202	void _image::move(int _direction)
203	{	203	{
204	int r, c;	204	int r, c;
205	dword first_element_data;	205	dword first_element_data;
206		206
207	switch(_direction)	207	switch(_direction)
208	{	208	{
209	case MOVE_LEFT:	209	case MOVE_LEFT:
210	for (r = 0; r < rows; r++)	210	for (r = 0; r < rows; r++)
211	{	211	{
212	first_element_data = get_pixel(r, 0);	212	first_element_data = get_pixel(r, 0);
213	for (c = 0; c < columns-1; c++) set_pixel(r, c, get_pixel(r, c+1));	213	for (c = 0; c < columns-1; c++) set_pixel(r, c, get_pixel(r, c+1));
214	set_pixel(r, columns-1, first_element_data);	214	set_pixel(r, columns-1, first_element_data);
215	}	215	}
216	break;	216	break;
217	case MOVE_RIGHT:	217	case MOVE_RIGHT:
218	for (r = 0; r < rows; r++)	218	for (r = 0; r < rows; r++)
219	{	219	{
220	first_element_data = get_pixel(r, columns-1);	220	first_element_data = get_pixel(r, columns-1);
221	for (c = columns-1; c > 0; c--) set_pixel(r, c, get_pixel(r, c-1));	221	for (c = columns-1; c > 0; c--) set_pixel(r, c, get_pixel(r, c-1));
222	set_pixel(r, 0, first_element_data);	222	set_pixel(r, 0, first_element_data);
223	}	223	}
224	break;	224	break;
225	case MOVE_UP:	225	case MOVE_UP:
226	for (c = 0; c < columns; c++)	226	for (c = 0; c < columns; c++)
227	{	227	{
228	first_element_data = get_pixel(0, c);	228	first_element_data = get_pixel(0, c);
229	for (r = 0; r < rows-1; r++) set_pixel(r, c, get_pixel(r+1, c));	229	for (r = 0; r < rows-1; r++) set_pixel(r, c, get_pixel(r+1, c));
230	set_pixel(rows-1, c, first_element_data);	230	set_pixel(rows-1, c, first_element_data);
231	}	231	}
232	break;	232	break;
233	case MOVE_DOWN:	233	case MOVE_DOWN:
234	for (c = 0; c < columns; c++)	234	for (c = 0; c < columns; c++)
235	{	235	{
236	first_element_data = get_pixel(rows-1, c);	236	first_element_data = get_pixel(rows-1, c);
237	for (r = rows-1; r > 0; r--) set_pixel(r, c, get_pixel(r-1, c));	237	for (r = rows-1; r > 0; r--) set_pixel(r, c, get_pixel(r-1, c));
238	set_pixel(0, c, first_element_data);	238	set_pixel(0, c, first_element_data);
239	}	239	}
240	break;	240	break;
241	case FLIP_HOR:	241	case FLIP_HOR:
242	for (r = 0; r < rows; r++)	242	for (r = 0; r < rows; r++)
243	for (c = 0; c < columns/2; c++) {	243	for (c = 0; c < columns/2; c++) {
244	first_element_data = get_pixel(r, c);	244	first_element_data = get_pixel(r, c);
245	set_pixel(r, c, get_pixel(r, columns-c-1));	245	set_pixel(r, c, get_pixel(r, columns-c-1));
246	set_pixel(r, columns-c-1, first_element_data);	246	set_pixel(r, columns-c-1, first_element_data);
247	}	247	}
248	break;	248	break;
249	case FLIP_VER:	249	case FLIP_VER:
250	for (c = 0; c < columns; c++)	250	for (c = 0; c < columns; c++)
251	for (r = 0; r < rows/2; r++) {	251	for (r = 0; r < rows/2; r++) {
252	first_element_data = get_pixel(r, c);	252	first_element_data = get_pixel(r, c);
253	set_pixel(r, c, get_pixel(rows-r-1, c));	253	set_pixel(r, c, get_pixel(rows-r-1, c));
254	set_pixel(rows-r-1, c, first_element_data);	254	set_pixel(rows-r-1, c, first_element_data);
255	}	255	}
256	break;	256	break;
257	}	257	}
258	}	258	}

Subversion Repositories Kolibri OS

(root)/programs/cmm/iconedit/colors_mas.h – Rev 7257 → 7259