| 11,7 → 11,7 |
|---|
| pipet aside color view |
| */ |
| |
| #define MEMSIZE 4096*40 |
| #define MEMSIZE 4096*100 |
| |
| #include "../lib/gui.h" |
| #include "../lib/random.h" |
| 28,7 → 28,7 |
|---|
| // // |
| //===================================================// |
| |
| #define T_TITLE "Icon Editor 0.45" |
| #define T_TITLE "Icon Editor 0.46 Alpha" |
| |
| #define TOOLBAR_H 24+8 |
| #define PANEL_LEFT_W 16+5+5+3+3 |
| 109,49 → 109,8 |
|---|
| libimg_image open_image; |
| _ActionsHistory actionsHistory; |
| |
| enum { |
| TOOL_NONE = -1, |
| TOOL_PENCIL, |
| TOOL_PIPETTE, |
| TOOL_FILL, |
| TOOL_LINE, |
| TOOL_RECT, |
| TOOL_SELECT |
| }; |
| #include "tools.h" |
| |
| struct Tool { |
| int id; |
| |
| void (*activate)(); |
| void (*deactivate)(); |
| void (*onMouseEvent)(int x, int y, int lkm, int pkm); |
| void (*onKeyEvent)(dword keycode); |
| void (*onCanvasDraw)(); |
| }; |
| |
| Tool tools[6]; |
| int currentTool = -1; |
| |
| 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(); |
| } |
| |
| //===================================================// |
| // // |
| // CODE // |
| 158,429 → 117,7 |
|---|
| // // |
| //===================================================// |
| |
| void FillTool_onMouseEvent(int mouseX, int mouseY, int lkm, int pkm) { |
| if (canvas.hovered()) && (currentTool==TOOL_FILL) && (mouse.up) |
| { |
| EventFill(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) { |
| 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 >= 32) |
| dx = 31 - selection_end_x; |
| |
| if (selection_start_y + dy < 0) |
| dy = selection_start_y; |
| |
| if (selection_end_y + dy >= 32) |
| dy = 31 - 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(); |
| |
| } |
| } |
| } |
| |
| void initTools() |
| { |
| tools[0].id = TOOL_PENCIL; |
| 624,15 → 161,20 |
|---|
| //system.color.get(); |
| //Libimg_ReplaceColor(tools_img.image, tools_img.w, tools_img.h, 0xFFF8C0D0, system.color.work); |
| |
| if (!param[0]) { |
| image.create(32, 32); |
| } |
| else |
| { |
| Libimg_LoadImage(#open_image, #param); |
| |
| if (param[0]) { |
| Libimg_LoadImage(#open_image, #param); |
| if (open_image.w==32) && (open_image.h==32) { |
| image.set_image(open_image.imgsrc); |
| if (open_image.w*open_image.h>MAX_CELL_SIZE*MAX_CELL_SIZE) { |
| notify("'Hey, this is just an icon editor,\nselected image is too big to open!' -E"); |
| ExitProcess(); |
| } |
| else { |
| notify("'Error: image format is unacceptable (PNG, 32x32x16b expected)' -E"); |
| image.create(open_image.w, open_image.h); |
| image.set_image(open_image.imgsrc); |
| } |
| } |
| |
| 858,7 → 400,7 |
|---|
| canvas.w = image.columns * zoom.value; |
| canvas.h = image.rows * zoom.value; |
| if (canvas.w+2 > wrapper.w) || (canvas.h+2 > wrapper.h) { |
| zoom.dec(); |
| zoom.value--; |
| DrawEditArea(); |
| return; |
| } |
| 980,37 → 522,9 |
|---|
| |
| void EventSave() |
| { |
| dword encoded_data=0; |
| dword encoded_size=0; |
| dword image_ptr = 0; |
| |
| image_ptr = create_image(Image_bpp24, 32, 32); |
| |
| if (image_ptr == 0) { |
| notify("'Error saving file, probably not enought memory!' -E"); |
| save_image(image.get_image(), image.columns, image.rows, "/rd/1/saved_image.png"); |
| } |
| else { |
| EDI = image_ptr; |
| memmov(EDI._Image.Data, image.get_image(), image.rows * image.columns * 3); |
| |
| encoded_data = encode_image(image_ptr, LIBIMG_FORMAT_PNG, 0, #encoded_size); |
| |
| img_destroy stdcall(image_ptr); |
| |
| if(encoded_data == 0) { |
| notify("'Error saving file, incorrect data!' -E"); |
| } |
| else { |
| if (CreateFile(encoded_size, encoded_data, "/rd/1/saved_image.png") == 0) { |
| notify("'File saved as /rd/1/saved_image.png' -O"); |
| } |
| else { |
| notify("'Error saving file, probably not enought space on ramdisk!' -E"); |
| } |
| } |
| } |
| } |
| |
| void EventSetActiveColor(int _number, _color) |
| { |
| int i; |
| 1025,140 → 539,3 |
|---|
| DrawActiveColor(NULL); |
| DrawColorPallets(); |
| } |
| |
| void EventFill(dword _r, _c, _color) |
| { |
| #define MARKED 6 |
| int r, c, i, restart; |
| |
| dword old_color = image.get_pixel(_r, _c); |
| image.set_pixel(_r, _c, MARKED); |
| |
| do { |
| restart=false; |
| for (r = 0; r < image.rows; r++) |
| for (c = 0; c < image.columns; c++) |
| { |
| IF (image.get_pixel(r,c) != old_color) continue; |
| IF (image.get_pixel(r,c) == MARKED) continue; |
| |
| IF (c>0) && (image.get_pixel(r,c-1) == MARKED) image.set_pixel(r,c,MARKED); |
| IF (r>0) && (image.get_pixel(r-1,c) == MARKED) image.set_pixel(r,c,MARKED); |
| IF (c<image.columns-1) && (image.get_pixel(r,c+1) == MARKED) image.set_pixel(r,c,MARKED); |
| IF (r<image.rows-1) && (image.get_pixel(r+1,c) == MARKED) image.set_pixel(r,c,MARKED); |
| |
| IF (image.get_pixel(r,c)==MARKED) restart=true; |
| } |
| }while(restart); |
| |
| for (i=0; i<image.columns*image.rows; i++) |
| IF (image.mas[i]==MARKED) image.mas[i] = _color; |
| } |
| |
| // 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; |
| |
| 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; |
| |
| if (target == 1) |
| image.set_pixel(y2, x2, color); |
| else |
| DrawBar(x2*zoom.value + canvas.x, y2*zoom.value + canvas.y, |
| zoom.value, zoom.value, color); |
| |
| while((x1 != x2) || (y1 != y2)) |
| { |
| if (target == 1) |
| image.set_pixel(y1, x1, color); |
| else |
| 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); |
| |
| } |
| } |
| } |