kolibrios/programs/cmm/iconedit/tools.h

enum {
	TOOL_NONE = -1,
	TOOL_PENCIL,
	TOOL_PIPETTE,
	TOOL_FILL,
	TOOL_LINE,
	TOOL_RECT,
	TOOL_SELECT
};

struct Tool {
	int id;
	
	void (*activate)();
	void (*deactivate)();
	void (*onMouseEvent)(int x, int y, int lkm, int pkm);
	void (*onKeyEvent)(dword keycode);
	void (*onCanvasDraw)();
};

int currentTool = -1;
Tool tools[6];


void resetCurrentTool() {
	if ((currentTool != TOOL_NONE) && (tools[currentTool].deactivate != 0)) {
		tools[currentTool].deactivate();
	}
	
	currentTool = TOOL_NONE;
}

void setCurrentTool(int index) {
	resetCurrentTool();

	currentTool = index;
	
	if ((index != TOOL_NONE) && (tools[index].activate != 0))
		tools[index].activate();

	DrawLeftPanel();
	DrawCanvas();
}

//===================================================//
//                                                   //
//                    FUNTIONS                       //
//                                                   //
//===================================================//

void FillTool_onMouseEvent(int mouseX, int mouseY, int lkm, int pkm) {
	if (canvas.hovered()) && (currentTool==TOOL_FILL) && (mouse.up)
	{
		image.fill(mouseY-canvas.y/zoom.value, 
				mouseX-canvas.x/zoom.value, tool_color);
		actionsHistory.saveCurrentState();			
		DrawCanvas();
	}
}

void PipetteTool_activate() {
	SetEventMask(EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE);
}

void PipetteTool_onMouseEvent(int mouseX, int mouseY, int lkm, int pkm) {
	tool_color = GetPixelUnderMouse();
	DrawBar(Form.cwidth-30, 5, 20, 20, tool_color);
	
	if (mouse.down) {
		DrawBar(Form.cwidth-30, 5, 20, 20, system.color.work);
		SetEventMask(EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER);
		if (mouse.key&MOUSE_LEFT) EventSetActiveColor(1, tool_color);
		if (mouse.key&MOUSE_RIGHT) EventSetActiveColor(2, tool_color);
		
		setCurrentTool(TOOL_PENCIL);
	}
}

bool PencilTool_Drawing = false;

void PencilTool_onMouseEvent(int mouseX, int mouseY, int lkm, int pkm) {
	if (canvas.hovered()) 
	{
		if ((PencilTool_Drawing == true) && (!mouse.key)) {
			actionsHistory.saveCurrentState();
			PencilTool_Drawing = false;
		}

		if (mouse.key) {
			image.set_pixel(mouseY-canvas.y/zoom.value, 
				mouseX-canvas.x/zoom.value, tool_color);
			PencilTool_Drawing = true;
		}
		DrawCanvas();
	}
}

void PencilTool_reset() {
	PencilTool_Drawing = false;
}

// Line tool
struct SimpleFigureTool_State {
	int startX, startY;
	int lastTempPosX, lastTempPosY;
};

enum {
	TOOL_LINE_STATE,
	TOOL_RECT_STATE
};

dword currentFigToolState = -1;
SimpleFigureTool_State figTool_States[2];

void SimpleFigureTool_Reset() {
	if (currentTool == TOOL_LINE)
		currentFigToolState = TOOL_LINE_STATE;
	else if (currentTool == TOOL_RECT)
		currentFigToolState = TOOL_RECT_STATE;

	figTool_States[currentFigToolState].startX = -1;
	figTool_States[currentFigToolState].startY = -1;
	figTool_States[currentFigToolState].lastTempPosX = -1;
	figTool_States[currentFigToolState].lastTempPosY = -1;
}

int mouseX_last;
int mouseY_last;
bool first_click_in_canvas = false;

void SimpleFigureTool_onMouseEvent(int mouseX, int mouseY, int lkm, int pkm) {
	if (mouse.down) && (canvas.hovered()) first_click_in_canvas = true;
	if (first_click_in_canvas)
	{
		if (mouseX>canvas.x+canvas.w-zoom.value) mouseX = canvas.x+canvas.w-zoom.value;
		if (mouseY>canvas.y+canvas.h-zoom.value) mouseY = canvas.y+canvas.h-zoom.value;
		if (mouseX<canvas.x) mouseX = canvas.x;
		if (mouseY<canvas.y) mouseY = canvas.y;

		if (mouse.key) {
			if ((figTool_States[currentFigToolState].startX < 0) 
			|| (figTool_States[currentFigToolState].startY < 0)) {
				figTool_States[currentFigToolState].startX = mouseX;
				figTool_States[currentFigToolState].startY = mouseY;
			}
			else {
				if ((calc(mouseX - canvas.x/zoom.value) != figTool_States[currentFigToolState].lastTempPosX)
					|| (calc(mouseY - canvas.y/zoom.value) != figTool_States[currentFigToolState].lastTempPosY)) 
				{
					DrawCanvas();
				}
			}
			mouseX_last = mouseX;
			mouseY_last = mouseY;
		}
		if (mouse.up) {
			if ((figTool_States[currentFigToolState].startX >= 0) 
			&& (figTool_States[currentFigToolState].startY >= 0)) {
				// Draw line from start position to current position
				if (currentTool == TOOL_LINE) {
					DrawLine(figTool_States[currentFigToolState].startX - canvas.x/zoom.value, 
						figTool_States[currentFigToolState].startY - canvas.y/zoom.value, 
						mouseX - canvas.x/zoom.value, 
						mouseY - canvas.y/zoom.value, 
						tool_color, 
						1);
				}
				else if (currentTool == TOOL_RECT) {
					DrawRectangleInCanvas(figTool_States[currentFigToolState].startX - canvas.x/zoom.value, 
						figTool_States[currentFigToolState].startY - canvas.y/zoom.value, 
						mouseX - canvas.x/zoom.value, 
						mouseY - canvas.y/zoom.value, tool_color, 1);
				}

				DrawCanvas();

				actionsHistory.saveCurrentState();

				// Reset start position
				figTool_States[currentFigToolState].startX = -1;
				figTool_States[currentFigToolState].startY = -1;

				first_click_in_canvas = false;
			}
		}
	}
}

void SimpleFigureTool_onCanvasDraw() {
	if ((figTool_States[currentFigToolState].startX >= 0) 
	&& (figTool_States[currentFigToolState].startY >= 0) && (mouse.key)) {
		if (currentTool == TOOL_LINE) {
			DrawLine(figTool_States[currentFigToolState].startX - canvas.x/zoom.value, 
				figTool_States[currentFigToolState].startY - canvas.y/zoom.value, 
				mouseX_last - canvas.x/zoom.value, 
				mouseY_last - canvas.y/zoom.value, 
				tool_color, 
				2);
		}
		else if (currentTool == TOOL_RECT) {
			DrawRectangleInCanvas(figTool_States[currentFigToolState].startX - canvas.x/zoom.value, 
				figTool_States[currentFigToolState].startY - canvas.y/zoom.value, 
				mouseX_last - canvas.x/zoom.value, 
				mouseY_last - canvas.y/zoom.value, 
				tool_color, 
				2);
		}

		figTool_States[currentFigToolState].lastTempPosX = mouseX_last - canvas.x/zoom.value;
		figTool_States[currentFigToolState].lastTempPosY = mouseY_last - canvas.y/zoom.value;
	}
}

// Selection
int selection_start_x = -1;
int selection_start_y = -1;
int selection_end_x = -1;
int selection_end_y = -1;
bool selection_active = false;

dword SelectionTool_buffer = 0;
dword SelectionTool_buffer_r = 0;
dword SelectionTool_buffer_c = 0;

bool selection_moving_started = false;
int selection_pivot_x = -1;
int selection_pivot_y = -1;

void SelectTool_normalizeSelection() {
	int t;

	// Restructuring of the selection coordinates
	if (selection_end_x < selection_start_x) {
		t = selection_start_x;
		selection_start_x = selection_end_x;
		selection_end_x = t;
	} 

	if (selection_end_y < selection_start_y) {
		t = selection_end_y;
		selection_end_y = selection_start_y;
		selection_start_y = t;
	}
}

void reset_selection_moving() {
	if (selection_moving_started) {
		SelectTool_drawBuffer(selection_start_x, selection_start_y, 1);

		selection_pivot_x = -1;
		selection_pivot_y = -1;
		
		selection_moving_started = false;
		
		actionsHistory.saveCurrentState();
		DrawCanvas();
	}
}

bool is_selection_moving() {
	return selection_moving_started;
}

void reset_selection() {
	reset_selection_moving();
	
	selection_start_x = -1;
	selection_start_y = -1;
	selection_end_x = -1;
	selection_end_y = -1;	
}

void SelectTool_activate() {
	reset_selection();

	selection_active = false;
}

void SelectTool_deactivate() {
	reset_selection_moving();
}

bool SelectTool_pointInSelection(int x, int y) {
	if (x >= selection_start_x) && (x <= selection_end_x) && (y >= selection_start_y) && (y <= selection_end_y)
		return true;
	else 
		return false;
}


void SelectTool_copyToBuffer() {
	dword offset, r, c;

		if (SelectionTool_buffer != 0)
			free(SelectionTool_buffer);

		SelectionTool_buffer_r = selection_end_y - selection_start_y + 1;
		SelectionTool_buffer_c = selection_end_x - selection_start_x + 1;
		SelectionTool_buffer = malloc(SelectionTool_buffer_r * SelectionTool_buffer_c * 4);

		for (r = selection_start_y; r <= selection_end_y; r++) {
			for (c = selection_start_x; c <= selection_end_x; c++) {
				offset = calc(SelectionTool_buffer_c * calc(r - selection_start_y) + calc(c - selection_start_x)) * 4;

				ESDWORD[SelectionTool_buffer + offset] = image.get_pixel(r, c);
			}
		}
}

void SelectTool_onMouseEvent(int mouseX, int mouseY, int lkm, int pkm) {
	int click_x, click_y, dx, dy, m_x, m_y, r, c, color;
	dword pixel;
	
	m_x = TO_CANVAS_X(mouseX);
	m_y = TO_CANVAS_Y(mouseY);
	
	if (mouse.down) && (canvas.hovered()) && (!selection_active) {
		if (selection_start_x != -1) && (SelectTool_pointInSelection(m_x, m_y)) {
			if (selection_pivot_x == -1) {
				selection_pivot_x = m_x;
				selection_pivot_y = m_y;
				
				GetKeys();
				
				if (!selection_moving_started) && ( !(key_modifier&KEY_LSHIFT) ) {
					for (r = selection_start_y; r <= selection_end_y; r++)
						for (c = selection_start_x; c <= selection_end_x; c++) {
							image.set_pixel(r, c, color2);
						}
				}
				
				selection_moving_started = true;
			}
		}
		else {
		
			reset_selection();
			selection_active = true;
		}
	}

	if (selection_pivot_x != -1) {
		dx = m_x - selection_pivot_x;
		dy = m_y - selection_pivot_y;

		if (selection_start_x + dx < 0)
			dx = selection_start_x;
		
		if (selection_end_x + dx >= image.columns)
			dx = image.columns-1 - selection_end_x;
		
		if (selection_start_y + dy < 0)
			dy = selection_start_y;
		
		if (selection_end_y + dy >= image.rows)
			dy = image.rows-1 - selection_end_y;
		
		
		selection_start_x += dx;
		selection_end_x += dx;
		
		selection_start_y += dy;
		selection_end_y += dy;
		
		selection_pivot_x += dx;
		selection_pivot_y += dy;
		
		DrawCanvas();
	}
	
	if (selection_active)
	{
		if (mouseX>canvas.x+canvas.w-zoom.value) mouseX = canvas.x+canvas.w-zoom.value;
		if (mouseY>canvas.y+canvas.h-zoom.value) mouseY = canvas.y+canvas.h-zoom.value;

		if (mouseX<canvas.x) mouseX = canvas.x;
		if (mouseY<canvas.y) mouseY = canvas.y;

		if (mouse.key) {
			selection_end_x = TO_CANVAS_X(mouseX);
			selection_end_y = TO_CANVAS_Y(mouseY);

			if ((selection_start_x < 0) || (selection_start_y < 0)) {
				selection_start_x = TO_CANVAS_X(mouseX);
				selection_start_y = TO_CANVAS_Y(mouseY);
			}
			else {
				DrawCanvas();

				/**if ((calc(TO_CANVAS_X(mouseX)) != selection_end_x)
					|| (calc(TO_CANVAS_Y(mouseY)) != selection_end_y)) 
				{
					DrawCanvas();
				}*/
			}

		}
		
		if (mouse.up) {			
			selection_active = false;
			
			SelectTool_normalizeSelection();
			SelectTool_copyToBuffer();
		}
	}
	
	if (mouse.up) {
		if (selection_pivot_x != -1) {
			selection_pivot_x = -1;
			selection_pivot_y = -1;
		}
	}
}

void SelectTool_onCanvasDraw() {	
	if (selection_moving_started)
		SelectTool_drawBuffer(selection_start_x, selection_start_y, 2);

	if ((selection_start_x >= 0) && (selection_start_y >= 0) && (selection_end_x >= 0) && (selection_end_y >= 0)) {
		DrawSelection(selection_start_x, selection_start_y, selection_end_x, selection_end_y);
	}	
}

void SelectTool_drawBuffer(int insert_x, int insert_y, int target) {
	dword color;
	dword offset, r, c;
	dword insert_to_x, insert_to_y;
	
	if (SelectionTool_buffer != 0) {
		insert_to_x = insert_x + SelectionTool_buffer_c - 1;
			
		if (insert_to_x >= image.columns)
			insert_to_x = image.columns-1;

		insert_to_y = insert_y + SelectionTool_buffer_r - 1;
			
		if (insert_to_y >= image.rows)
			insert_to_y = image.rows-1;

		for (r = insert_y; r <= insert_to_y; r++) {
			for (c = insert_x; c <= insert_to_x; c++) {
					offset = calc(SelectionTool_buffer_c * calc(r - insert_y) + calc(c - insert_x)) * 4;

					color = ESDWORD[SelectionTool_buffer + offset];
					
					if (target == 1)
						image.set_pixel(r, c, color);
					else
						DrawBar(c*zoom.value + canvas.x, r*zoom.value + canvas.y, 
							zoom.value, zoom.value, color);
			}
		}	
	}	
}

void SelectTool_onKeyEvent(dword keycode) {
	dword offset, r, c;
	dword insert_x, insert_y, insert_to_x, insert_to_y;

	if (keycode == SCAN_CODE_KEY_V) {
		if (SelectionTool_buffer != 0) {
			reset_selection();
			
			selection_moving_started = true;
			selection_start_x = 0;
			selection_end_x = SelectionTool_buffer_c - 1;
			
			selection_start_y = 0;
			selection_end_y = SelectionTool_buffer_r - 1;
			
			DrawCanvas();
	
		}
	}
}


//===================================================//
//                                                   //
//                      DRAWs                        //
//                                                   //
//===================================================//



// target - image (1) or canvas (2)
void DrawLine(int x1, int y1, int x2, int y2, dword color, int target) {
	int dx, dy, signX, signY, error, error2;

	if (1==target) {
		image.draw_line(x1, y1, x2, y2, color);
		return;
	}
	
	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;

	DrawBar(x2*zoom.value + canvas.x, y2*zoom.value + canvas.y, 
			zoom.value, zoom.value, color);

	while((x1 != x2) || (y1 != y2)) 
	{
		DrawBar(x1*zoom.value + canvas.x, y1*zoom.value + canvas.y, 
			zoom.value, zoom.value, color);
		
	   error2 = error * 2;

       if(error2 > calc(-dy)) 
       {
           error -= dy;
           x1 += signX;
       }
	   
       if(error2 < dx) 
       {
           error += dx;
           y1 += signY;
       }
	}
}

void DrawRectangleInCanvas(int x1, int y1, int x2, int y2, dword color, int target) {
	DrawLine(x1, y1, x2, y1, color, target);
	DrawLine(x2, y1, x2, y2, color, target);
	DrawLine(x2, y2, x1, y2, color, target);
	DrawLine(x1, y2, x1, y1, color, target);
}

#define SELECTION_COLOR 0xAAE5EF

void DrawSelection(int x1, int y1, int x2, int y2) {
	int p1x, p1y, p2x, p2y, r, c, old_color, new_color;
	dword offset;

	if (x1 <= x2) {
		p1x = x1;
		p2x = x2;
	}
	else {
		p1x = x2;
		p2x = x1;
	}

	if (y1 <= y2) {
		p2y = y1;
		p1y = y2;
	}
	else {
		p2y = y2;
		p1y = y1;
	}

	for (r = p1y; r >= p2y; r--) {
		for (c = p1x; c <= p2x; c++) {
			
			if (selection_moving_started) && (SelectTool_pointInSelection(c, r)) {
				offset = calc(SelectionTool_buffer_c * calc(r - selection_start_y) + calc(c - selection_start_x)) * 4;
				old_color = ESDWORD[SelectionTool_buffer + offset];
			}
			else {
				old_color = image.get_pixel(r, c);
			}
			
			new_color = MixColors(old_color, SELECTION_COLOR, 64);
			
			DrawBar(c*zoom.value + canvas.x, r*zoom.value + canvas.y, 
				zoom.value, zoom.value, new_color);

		}
	}
}