berkus
/
essence-os
mirror of https://gitlab.com/nakst/essence
1
0
Fork 0
Code Releases Activity
essence-os/apps/image_editor.cpp

932 lines
34 KiB
C++
Raw Blame History

// This file is part of the Essence operating system.
// It is released under the terms of the MIT license -- see LICENSE.md.
// Written by: nakst.
// TODO Saving.
// TODO Don't use an EsPaintTarget for the bitmap?
// TODO Show brush preview.
// TODO Other tools: text, selection.
// TODO Resize and crop image.
// TODO Clipboard.
// TODO Clearing textbox undo from EsTextboxInsert?
// TODO Handling out of memory.
// TODO Color palette.
// TODO More brushes?
// TODO Grid.
// TODO Zoom and pan with EsCanvasPane.
// TODO Status bar.
// TODO Clearing undo if too much memory is used.
#define ES_INSTANCE_TYPE Instance
#include <essence.h>
#include <shared/array.cpp>
#include <shared/strings.cpp>
#define STB_IMAGE_WRITE_IMPLEMENTATION
#define STBI_WRITE_NO_STDIO
#define STBIW_MEMMOVE EsCRTmemmove
#define STBIW_MALLOC(sz) EsCRTmalloc(sz)
#define STBIW_REALLOC(p,newsz) EsCRTrealloc(p,newsz)
#define STBIW_FREE(p) EsCRTfree(p)
#define STBIW_ASSERT EsAssert
#include <shared/stb_image_write.h>
#define TILE_SIZE (128)
struct Tile {
size_t referenceCount;
uint64_t ownerID;
uint32_t bits[TILE_SIZE * TILE_SIZE];
};
struct Image {
Tile **tiles;
size_t tileCountX, tileCountY;
uint64_t id;
uint32_t width, height;
};
struct Instance : EsInstance {
EsElement *canvas;
EsColorWell *colorWell;
EsTextbox *brushSize;
EsPanel *toolPanel;
EsButton *toolDropdown;
EsPaintTarget *bitmap;
uint32_t bitmapWidth, bitmapHeight;
Image image;
uint64_t nextImageID;
EsCommand commandBrush;
EsCommand commandFill;
EsCommand commandRectangle;
EsCommand commandSelect;
EsCommand commandText;
// Data while drawing:
EsRectangle modifiedBounds;
float previousPointX, previousPointY;
bool dragged;
};
const EsInstanceClassEditorSettings editorSettings = {
INTERFACE_STRING(ImageEditorNewFileName),
INTERFACE_STRING(ImageEditorNewDocument),
ES_ICON_IMAGE_X_GENERIC,
};
const EsStyle styleImageMenuTable = {
.inherit = ES_STYLE_PANEL_FORM_TABLE,
.metrics = {
.mask = ES_THEME_METRICS_INSETS,
.insets = ES_RECT_4(20, 20, 5, 8),
},
};
Image ImageFork(Instance *instance, Image image, uint32_t newWidth = 0, uint32_t newHeight = 0) {
Image copy = image;
copy.width = newWidth ?: image.width;
copy.height = newHeight ?: image.height;
copy.tileCountX = newWidth ? (newWidth + TILE_SIZE - 1) / TILE_SIZE : image.tileCountX;
copy.tileCountY = newHeight ? (newHeight + TILE_SIZE - 1) / TILE_SIZE : image.tileCountY;
copy.id = instance->nextImageID++;
copy.tiles = (Tile **) EsHeapAllocate(copy.tileCountX * copy.tileCountY * sizeof(Tile *), true);
for (uintptr_t y = 0; y < copy.tileCountY; y++) {
for (uintptr_t x = 0; x < copy.tileCountX; x++) {
uintptr_t source = y * image.tileCountX + x;
uintptr_t destination = y * copy.tileCountX + x;
if (y < image.tileCountY && x < image.tileCountX && image.tiles[source]) {
image.tiles[source]->referenceCount++;
copy.tiles[destination] = image.tiles[source];
}
}
}
return copy;
}
void ImageDelete(Image image) {
for (uintptr_t i = 0; i < image.tileCountX * image.tileCountY; i++) {
image.tiles[i]->referenceCount--;
if (!image.tiles[i]->referenceCount) {
// EsPrint("free tile %d, %d from image %d\n", i % image.tileCountX, i / image.tileCountX, image.tiles[i]->ownerID);
EsHeapFree(image.tiles[i]);
}
}
EsHeapFree(image.tiles);
}
void ImageCopyToPaintTarget(Instance *instance, const Image *image) {
uint32_t *bits;
size_t width, height, stride;
EsPaintTargetStartDirectAccess(instance->bitmap, &bits, &width, &height, &stride);
for (int32_t i = 0; i < (int32_t) image->tileCountY; i++) {
for (int32_t j = 0; j < (int32_t) image->tileCountX; j++) {
Tile *tile = image->tiles[i * image->tileCountX + j];
int32_t copyWidth = TILE_SIZE, copyHeight = TILE_SIZE;
if (j * TILE_SIZE + copyWidth > (int32_t) width) {
copyWidth = width - j * TILE_SIZE;
}
if (i * TILE_SIZE + copyHeight > (int32_t) height) {
copyHeight = height - i * TILE_SIZE;
}
if (tile) {
for (int32_t y = 0; y < copyHeight; y++) {
for (int32_t x = 0; x < copyWidth; x++) {
bits[stride / 4 * (y + i * TILE_SIZE) + (x + j * TILE_SIZE)] = tile->bits[y * TILE_SIZE + x];
}
}
} else {
for (int32_t y = 0; y < copyHeight; y++) {
for (int32_t x = 0; x < copyWidth; x++) {
bits[stride / 4 * (y + i * TILE_SIZE) + (x + j * TILE_SIZE)] = 0;
}
}
}
}
}
EsPaintTargetEndDirectAccess(instance->bitmap);
}
Tile *ImageUpdateTile(Image *image, uint32_t x, uint32_t y, bool copyOldBits) {
EsAssert(x < image->tileCountX && y < image->tileCountY);
Tile **tileReference = image->tiles + y * image->tileCountX + x;
Tile *tile = *tileReference;
if (!tile || tile->ownerID != image->id) {
if (tile && tile->referenceCount == 1) {
tile->ownerID = image->id;
// EsPrint("reuse tile %d, %d for image %d\n", x, y, image->id);
} else {
Tile *old = tile;
if (old) old->referenceCount--;
*tileReference = tile = (Tile *) EsHeapAllocate(sizeof(Tile), false);
tile->referenceCount = 1;
tile->ownerID = image->id;
if (copyOldBits && old) {
EsMemoryCopy(tile->bits, old->bits, sizeof(old->bits));
}
// EsPrint("allocate new tile %d, %d for image %d\n", x, y, image->id);
}
}
return tile;
}
void ImageCopyFromPaintTarget(Instance *instance, Image *image, EsRectangle modifiedBounds) {
uint32_t *bits;
size_t width, height, stride;
EsPaintTargetStartDirectAccess(instance->bitmap, &bits, &width, &height, &stride);
modifiedBounds = EsRectangleIntersection(modifiedBounds, ES_RECT_4(0, width, 0, height));
for (int32_t i = modifiedBounds.t / TILE_SIZE; i <= modifiedBounds.b / TILE_SIZE; i++) {
for (int32_t j = modifiedBounds.l / TILE_SIZE; j <= modifiedBounds.r / TILE_SIZE; j++) {
if ((uint32_t) j >= image->tileCountX || (uint32_t) i >= image->tileCountY) {
continue;
}
Tile *tile = ImageUpdateTile(image, j, i, false);
int32_t copyWidth = TILE_SIZE, copyHeight = TILE_SIZE;
if (j * TILE_SIZE + copyWidth > (int32_t) width) {
copyWidth = width - j * TILE_SIZE;
}
if (i * TILE_SIZE + copyHeight > (int32_t) height) {
copyHeight = height - i * TILE_SIZE;
}
for (int32_t y = 0; y < copyHeight; y++) {
for (int32_t x = 0; x < copyWidth; x++) {
tile->bits[y * TILE_SIZE + x] = bits[stride / 4 * (y + i * TILE_SIZE) + (x + j * TILE_SIZE)];
}
}
}
}
EsPaintTargetEndDirectAccess(instance->bitmap);
}
void ImageUndoMessage(const void *item, EsUndoManager *manager, EsMessage *message) {
const Image *image = (const Image *) item;
Instance *instance = EsUndoGetInstance(manager);
if (message->type == ES_MSG_UNDO_INVOKE) {
EsUndoPush(manager, ImageUndoMessage, &instance->image, sizeof(Image));
instance->image = *image;
if (instance->bitmapWidth != image->width || instance->bitmapHeight != image->height) {
instance->bitmapWidth = image->width;
instance->bitmapHeight = image->height;
EsPaintTargetDestroy(instance->bitmap);
instance->bitmap = EsPaintTargetCreate(instance->bitmapWidth, instance->bitmapHeight, false);
EsElementRelayout(EsElementGetLayoutParent(instance->canvas));
}
ImageCopyToPaintTarget(instance, image);
EsElementRepaint(instance->canvas);
} else if (message->type == ES_MSG_UNDO_CANCEL) {
ImageDelete(*image);
}
}
int BrushSizeMessage(EsElement *element, EsMessage *message) {
EsTextbox *textbox = (EsTextbox *) element;
if (message->type == ES_MSG_TEXTBOX_NUMBER_DRAG_DELTA) {
double oldValue = EsTextboxGetContentsAsDouble(textbox);
double newValue = oldValue + message->numberDragDelta.delta * (message->numberDragDelta.fast ? 1 : 0.1);
if (newValue < 1) {
newValue = 1;
} else if (newValue > 200) {
newValue = 200;
}
char result[64];
size_t resultBytes = EsStringFormat(result, sizeof(result), "%d.%d", (int) newValue, (int) (newValue * 10) % 10);
EsTextboxSelectAll(textbox);
EsTextboxInsert(textbox, result, resultBytes);
}
return 0;
}
EsRectangle DrawFill(Instance *instance, EsPoint point) {
uint32_t color = 0xFF000000 | EsColorWellGetRGB(instance->colorWell);
EsRectangle modifiedBounds = ES_RECT_4(point.x, point.x, point.y, point.y);
if ((uint32_t) point.x >= instance->bitmapWidth || (uint32_t) point.y >= instance->bitmapHeight) {
return {};
}
uint32_t *bits;
size_t width, height, stride;
EsPaintTargetStartDirectAccess(instance->bitmap, &bits, &width, &height, &stride);
stride /= 4;
Array<EsPoint> pointsToVisit = {};
uint32_t replaceColor = bits[point.y * stride + point.x];
if (replaceColor != color) pointsToVisit.Add(point);
while (pointsToVisit.Length()) {
EsPoint startPoint = pointsToVisit.Pop();
if (startPoint.y < modifiedBounds.t) {
modifiedBounds.t = startPoint.y;
}
if (startPoint.y > modifiedBounds.b) {
modifiedBounds.b = startPoint.y;
}
for (ptrdiff_t delta = -1; delta <= 1; delta += 2) {
EsPoint point = startPoint;
uint32_t *pointer = bits + point.y * stride + point.x;
bool spaceAbove = false;
bool spaceBelow = false;
if (delta == 1) {
point.x += delta;
pointer += delta;
if (point.x == (int32_t) width) {
break;
}
}
while (true) {
if (*pointer != replaceColor) {
break;
}
*pointer = color;
if (point.x < modifiedBounds.l) {
modifiedBounds.l = point.x;
}
if (point.x > modifiedBounds.r) {
modifiedBounds.r = point.x;
}
if (point.y) {
if (!spaceAbove && pointer[-stride] == replaceColor) {
spaceAbove = true;
pointsToVisit.Add({ point.x, point.y - 1 });
} else if (spaceAbove && pointer[-stride] != replaceColor) {
spaceAbove = false;
}
}
if (point.y != (int32_t) height - 1) {
if (!spaceBelow && pointer[stride] == replaceColor) {
spaceBelow = true;
pointsToVisit.Add({ point.x, point.y + 1 });
} else if (spaceBelow && pointer[stride] != replaceColor) {
spaceBelow = false;
}
}
point.x += delta;
pointer += delta;
if (point.x == (int32_t) width || point.x < 0) {
break;
}
}
}
}
modifiedBounds.r++, modifiedBounds.b += 2;
pointsToVisit.Free();
EsPaintTargetEndDirectAccess(instance->bitmap);
EsElementRepaint(instance->canvas, &modifiedBounds);
return modifiedBounds;
}
EsRectangle DrawLine(Instance *instance, bool force = false) {
EsPoint point = EsMouseGetPosition(instance->canvas);
float brushSize = EsTextboxGetContentsAsDouble(instance->brushSize);
float spacing = brushSize * 0.1f;
uint32_t color = 0xFF000000 | EsColorWellGetRGB(instance->colorWell);
EsRectangle modifiedBounds = ES_RECT_4(instance->bitmapWidth, 0, instance->bitmapHeight, 0);
uint32_t *bits;
size_t width, height, stride;
EsPaintTargetStartDirectAccess(instance->bitmap, &bits, &width, &height, &stride);
stride /= 4;
// Draw the line.
while (true) {
float dx = point.x - instance->previousPointX;
float dy = point.y - instance->previousPointY;
float distance = EsCRTsqrtf(dx * dx + dy * dy);
if (distance < spacing && !force) {
break;
}
int32_t x0 = instance->previousPointX;
int32_t y0 = instance->previousPointY;
EsRectangle bounds = ES_RECT_4(x0 - brushSize / 2 - 1, x0 + brushSize / 2 + 1,
y0 - brushSize / 2 - 1, y0 + brushSize / 2 + 1);
bounds = EsRectangleIntersection(bounds, ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight));
modifiedBounds = EsRectangleBounding(modifiedBounds, bounds);
for (int32_t y = bounds.t; y < bounds.b; y++) {
for (int32_t x = bounds.l; x < bounds.r; x++) {
float distance = (x - x0) * (x - x0) + (y - y0) * (y - y0);
if (distance < brushSize * brushSize * 0.25f) {
bits[y * stride + x] = color;
}
}
}
if (force) {
break;
}
instance->previousPointX += dx / distance * spacing;
instance->previousPointY += dy / distance * spacing;
}
// Repaint the canvas.
modifiedBounds.r++, modifiedBounds.b++;
EsPaintTargetEndDirectAccess(instance->bitmap);
EsElementRepaint(instance->canvas, &modifiedBounds);
return modifiedBounds;
}
int CanvasMessage(EsElement *element, EsMessage *message) {
Instance *instance = element->instance;
if (message->type == ES_MSG_PAINT) {
EsPainter *painter = message->painter;
EsRectangle bounds = EsPainterBoundsInset(painter);
EsRectangle area = ES_RECT_4(bounds.l, bounds.l + instance->bitmapWidth, bounds.t, bounds.t + instance->bitmapHeight);
EsDrawPaintTarget(painter, instance->bitmap, area, ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight), 0xFF);
if (instance->commandRectangle.check == ES_CHECK_CHECKED && instance->dragged) {
EsRectangle rectangle = instance->modifiedBounds;
rectangle.l += painter->offsetX, rectangle.r += painter->offsetX;
rectangle.t += painter->offsetY, rectangle.b += painter->offsetY;
EsDrawBlock(painter, EsRectangleIntersection(rectangle, area), 0xFF000000 | EsColorWellGetRGB(instance->colorWell));
}
} else if ((message->type == ES_MSG_MOUSE_LEFT_DRAG || message->type == ES_MSG_MOUSE_MOVED)
&& EsMouseIsLeftHeld() && instance->commandBrush.check == ES_CHECK_CHECKED) {
instance->modifiedBounds = EsRectangleBounding(DrawLine(instance), instance->modifiedBounds);
} else if (message->type == ES_MSG_MOUSE_LEFT_DRAG && instance->commandRectangle.check == ES_CHECK_CHECKED) {
EsRectangle previous = instance->modifiedBounds;
EsPoint point = EsMouseGetPosition(element);
EsRectangle rectangle;
if (point.x < instance->previousPointX) rectangle.l = point.x, rectangle.r = instance->previousPointX + 1;
else rectangle.l = instance->previousPointX, rectangle.r = point.x + 1;
if (point.y < instance->previousPointY) rectangle.t = point.y, rectangle.b = instance->previousPointY + 1;
else rectangle.t = instance->previousPointY, rectangle.b = point.y + 1;
instance->modifiedBounds = rectangle;
EsRectangle bounding = EsRectangleBounding(rectangle, previous);
EsElementRepaint(element, &bounding);
instance->dragged = true;
} else if (message->type == ES_MSG_MOUSE_LEFT_DOWN && instance->commandBrush.check == ES_CHECK_CHECKED) {
EsUndoPush(instance->undoManager, ImageUndoMessage, &instance->image, sizeof(Image));
instance->image = ImageFork(instance, instance->image);
EsPoint point = EsMouseGetPosition(element);
instance->previousPointX = point.x, instance->previousPointY = point.y;
instance->modifiedBounds = ES_RECT_4(instance->bitmapWidth, 0, instance->bitmapHeight, 0);
DrawLine(instance, true);
} else if (message->type == ES_MSG_MOUSE_LEFT_DOWN && instance->commandRectangle.check == ES_CHECK_CHECKED) {
EsPoint point = EsMouseGetPosition(element);
instance->previousPointX = point.x, instance->previousPointY = point.y;
instance->dragged = false;
} else if (message->type == ES_MSG_MOUSE_LEFT_UP && instance->commandBrush.check == ES_CHECK_CHECKED) {
ImageCopyFromPaintTarget(instance, &instance->image, instance->modifiedBounds);
} else if (message->type == ES_MSG_MOUSE_LEFT_UP && instance->commandRectangle.check == ES_CHECK_CHECKED && instance->dragged) {
instance->dragged = false;
EsUndoPush(instance->undoManager, ImageUndoMessage, &instance->image, sizeof(Image));
instance->image = ImageFork(instance, instance->image);
EsPainter painter = {};
painter.clip = ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight);
painter.target = instance->bitmap;
EsDrawBlock(&painter, instance->modifiedBounds, 0xFF000000 | EsColorWellGetRGB(instance->colorWell));
ImageCopyFromPaintTarget(instance, &instance->image, instance->modifiedBounds);
} else if (message->type == ES_MSG_MOUSE_LEFT_UP && instance->commandFill.check == ES_CHECK_CHECKED) {
EsUndoPush(instance->undoManager, ImageUndoMessage, &instance->image, sizeof(Image));
instance->image = ImageFork(instance, instance->image);
EsRectangle modifiedBounds = DrawFill(instance, EsMouseGetPosition(element));
ImageCopyFromPaintTarget(instance, &instance->image, modifiedBounds);
} else if (message->type == ES_MSG_GET_CURSOR) {
message->cursorStyle = ES_CURSOR_CROSS_HAIR_PICK;
} else if (message->type == ES_MSG_GET_WIDTH) {
message->measure.width = instance->bitmapWidth;
} else if (message->type == ES_MSG_GET_HEIGHT) {
message->measure.height = instance->bitmapHeight;
} else {
return 0;
}
return ES_HANDLED;
}
void CommandSelectTool(Instance *instance, EsElement *, EsCommand *command) {
if (command->check == ES_CHECK_CHECKED) {
return;
}
EsCommandSetCheck(&instance->commandBrush, ES_CHECK_UNCHECKED, false);
EsCommandSetCheck(&instance->commandFill, ES_CHECK_UNCHECKED, false);
EsCommandSetCheck(&instance->commandRectangle, ES_CHECK_UNCHECKED, false);
EsCommandSetCheck(&instance->commandSelect, ES_CHECK_UNCHECKED, false);
EsCommandSetCheck(&instance->commandText, ES_CHECK_UNCHECKED, false);
EsCommandSetCheck(command, ES_CHECK_CHECKED, false);
if (command == &instance->commandBrush) EsButtonSetIcon(instance->toolDropdown, ES_ICON_DRAW_FREEHAND);
if (command == &instance->commandFill) EsButtonSetIcon(instance->toolDropdown, ES_ICON_COLOR_FILL);
if (command == &instance->commandRectangle) EsButtonSetIcon(instance->toolDropdown, ES_ICON_DRAW_RECTANGLE);
if (command == &instance->commandSelect) EsButtonSetIcon(instance->toolDropdown, ES_ICON_OBJECT_GROUP);
if (command == &instance->commandText) EsButtonSetIcon(instance->toolDropdown, ES_ICON_DRAW_TEXT);
instance->dragged = false;
}
int BitmapSizeTextboxMessage(EsElement *element, EsMessage *message) {
EsTextbox *textbox = (EsTextbox *) element;
Instance *instance = textbox->instance;
if (message->type == ES_MSG_TEXTBOX_EDIT_END || message->type == ES_MSG_TEXTBOX_NUMBER_DRAG_END) {
char *expression = EsTextboxGetContents(textbox);
EsCalculationValue value = EsCalculateFromUserExpression(expression);
EsHeapFree(expression);
if (value.error) {
return ES_REJECTED;
}
if (value.number < 1) value.number = 1;
else if (value.number > 20000) value.number = 20000;
int newSize = (int) (value.number + 0.5);
char result[64];
size_t resultBytes = EsStringFormat(result, sizeof(result), "%d", newSize);
EsTextboxSelectAll(textbox);
EsTextboxInsert(textbox, result, resultBytes);
int oldSize = textbox->userData.i ? instance->bitmapHeight : instance->bitmapWidth;
if (oldSize == newSize) {
return ES_HANDLED;
}
EsRectangle clearRegion;
if (textbox->userData.i) {
instance->bitmapHeight = newSize;
clearRegion = ES_RECT_4(0, instance->bitmapWidth, oldSize, newSize);
} else {
instance->bitmapWidth = newSize;
clearRegion = ES_RECT_4(oldSize, newSize, 0, instance->bitmapHeight);
}
EsUndoPush(instance->undoManager, ImageUndoMessage, &instance->image, sizeof(Image));
instance->image = ImageFork(instance, instance->image, instance->bitmapWidth, instance->bitmapHeight);
EsPaintTargetDestroy(instance->bitmap);
instance->bitmap = EsPaintTargetCreate(instance->bitmapWidth, instance->bitmapHeight, false);
ImageCopyToPaintTarget(instance, &instance->image);
EsPainter painter = {};
painter.clip = ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight);
painter.target = instance->bitmap;
EsDrawBlock(&painter, clearRegion, 0xFFFFFFFF);
ImageCopyFromPaintTarget(instance, &instance->image, clearRegion);
EsElementRelayout(EsElementGetLayoutParent(instance->canvas));
return ES_HANDLED;
} else if (message->type == ES_MSG_TEXTBOX_NUMBER_DRAG_DELTA) {
int oldValue = EsTextboxGetContentsAsDouble(textbox);
int newValue = oldValue + message->numberDragDelta.delta * (message->numberDragDelta.fast ? 10 : 1);
if (newValue < 1) newValue = 1;
else if (newValue > 20000) newValue = 20000;
char result[64];
size_t resultBytes = EsStringFormat(result, sizeof(result), "%d", newValue);
EsTextboxSelectAll(textbox);
EsTextboxInsert(textbox, result, resultBytes);
return ES_HANDLED;
}
return 0;
}
void ImageTransform(EsMenu *menu, EsGeneric context) {
Instance *instance = menu->instance;
EsUndoPush(instance->undoManager, ImageUndoMessage, &instance->image, sizeof(Image));
uint32_t *bits;
size_t width, height, stride;
EsPaintTargetStartDirectAccess(instance->bitmap, &bits, &width, &height, &stride);
EsPaintTarget *newTarget = nullptr;
uint32_t *newBits = nullptr;
size_t newStride = 0;
if (context.i == 1 || context.i == 2) {
instance->image = ImageFork(instance, instance->image, height, width);
newTarget = EsPaintTargetCreate(height, width, false);
EsPaintTargetStartDirectAccess(newTarget, &newBits, &height, &width, &newStride);
} else {
instance->image = ImageFork(instance, instance->image);
}
if (context.i == 1 /* rotate left */) {
for (uintptr_t i = 0; i < height; i++) {
for (uintptr_t j = 0; j < width; j++) {
newBits[(width - j - 1) * newStride / 4 + i] = bits[i * stride / 4 + j];
}
}
} else if (context.i == 2 /* rotate right */) {
for (uintptr_t i = 0; i < height; i++) {
for (uintptr_t j = 0; j < width; j++) {
newBits[j * newStride / 4 + (height - i - 1)] = bits[i * stride / 4 + j];
}
}
} else if (context.i == 3 /* flip horizontally */) {
for (uintptr_t i = 0; i < height; i++) {
for (uintptr_t j = 0; j < width / 2; j++) {
uint32_t temporary = bits[i * stride / 4 + j];
bits[i * stride / 4 + j] = bits[i * stride / 4 + (width - j - 1)];
bits[i * stride / 4 + (width - j - 1)] = temporary;
}
}
} else if (context.i == 4 /* flip vertically */) {
for (uintptr_t i = 0; i < height / 2; i++) {
for (uintptr_t j = 0; j < width; j++) {
uint32_t temporary = bits[i * stride / 4 + j];
bits[i * stride / 4 + j] = bits[(height - i - 1) * stride / 4 + j];
bits[(height - i - 1) * stride / 4 + j] = temporary;
}
}
}
EsPaintTargetEndDirectAccess(instance->bitmap);
if (newTarget) {
EsPaintTargetDestroy(instance->bitmap);
instance->bitmap = newTarget;
size_t width, height;
EsPaintTargetGetSize(instance->bitmap, &width, &height);
instance->bitmapWidth = width;
instance->bitmapHeight = height;
EsElementRelayout(EsElementGetLayoutParent(instance->canvas));
}
ImageCopyFromPaintTarget(instance, &instance->image, ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight));
EsElementRepaint(instance->canvas);
}
void MenuTools(Instance *instance, EsElement *element, EsCommand *) {
EsMenu *menu = EsMenuCreate(element);
EsMenuAddCommandsFromToolbar(menu, instance->toolPanel);
EsMenuShow(menu);
}
void MenuImage(Instance *instance, EsElement *element, EsCommand *) {
EsMenu *menu = EsMenuCreate(element);
EsMenuAddItem(menu, ES_MENU_ITEM_HEADER, INTERFACE_STRING(ImageEditorCanvasSize));
EsPanel *table = EsPanelCreate(menu, ES_PANEL_HORIZONTAL | ES_PANEL_TABLE, EsStyleIntern(&styleImageMenuTable));
EsPanelSetBands(table, 2, 2);
char buffer[64];
size_t bytes;
EsTextbox *textbox;
bytes = EsStringFormat(buffer, sizeof(buffer), "%d", instance->bitmapWidth);
EsTextDisplayCreate(table, ES_CELL_H_RIGHT, ES_STYLE_TEXT_LABEL, INTERFACE_STRING(ImageEditorPropertyWidth));
textbox = EsTextboxCreate(table, ES_TEXTBOX_EDIT_BASED, ES_STYLE_TEXTBOX_BORDERED_SINGLE_MEDIUM);
EsTextboxInsert(textbox, buffer, bytes, false);
textbox->userData.i = 0;
textbox->messageUser = BitmapSizeTextboxMessage;
EsTextboxUseNumberOverlay(textbox, true);
bytes = EsStringFormat(buffer, sizeof(buffer), "%d", instance->bitmapHeight);
EsTextDisplayCreate(table, ES_CELL_H_RIGHT, ES_STYLE_TEXT_LABEL, INTERFACE_STRING(ImageEditorPropertyHeight));
textbox = EsTextboxCreate(table, ES_TEXTBOX_EDIT_BASED, ES_STYLE_TEXTBOX_BORDERED_SINGLE_MEDIUM);
EsTextboxInsert(textbox, buffer, bytes, false);
textbox->userData.i = 1;
textbox->messageUser = BitmapSizeTextboxMessage;
EsTextboxUseNumberOverlay(textbox, true);
EsMenuAddSeparator(menu);
EsMenuAddItem(menu, ES_MENU_ITEM_HEADER, INTERFACE_STRING(ImageEditorImageTransformations));
EsMenuAddItem(menu, ES_FLAGS_DEFAULT, INTERFACE_STRING(ImageEditorRotateLeft), ImageTransform, 1);
EsMenuAddItem(menu, ES_FLAGS_DEFAULT, INTERFACE_STRING(ImageEditorRotateRight), ImageTransform, 2);
EsMenuAddItem(menu, ES_FLAGS_DEFAULT, INTERFACE_STRING(ImageEditorFlipHorizontally), ImageTransform, 3);
EsMenuAddItem(menu, ES_FLAGS_DEFAULT, INTERFACE_STRING(ImageEditorFlipVertically), ImageTransform, 4);
EsMenuShow(menu);
}
void WriteCallback(void *context, void *data, int size) {
EsBufferWrite((EsBuffer *) context, data, size);
}
void SwapRedAndBlueChannels(uint32_t *bits, size_t width, size_t height, size_t stride) {
for (uintptr_t i = 0; i < height; i++) {
for (uintptr_t j = 0; j < width; j++) {
uint32_t *pixel = &bits[i * stride / 4 + j];
*pixel = (*pixel & 0xFF00FF00) | (((*pixel >> 16) | (*pixel << 16)) & 0x00FF00FF);
}
}
}
int InstanceCallback(Instance *instance, EsMessage *message) {
if (message->type == ES_MSG_INSTANCE_DESTROY) {
EsPaintTargetDestroy(instance->bitmap);
ImageDelete(instance->image);
} else if (message->type == ES_MSG_INSTANCE_SAVE) {
// TODO Error handling.
uintptr_t extensionOffset = message->instanceSave.nameOrPathBytes;
while (extensionOffset) {
if (message->instanceSave.nameOrPath[extensionOffset - 1] == '.') {
break;
} else {
extensionOffset--;
}
}
const char *extension = extensionOffset ? message->instanceSave.nameOrPath + extensionOffset : "png";
size_t extensionBytes = extensionOffset ? message->instanceSave.nameOrPathBytes - extensionOffset : 3;
uint32_t *bits;
size_t width, height, stride;
EsPaintTargetStartDirectAccess(instance->bitmap, &bits, &width, &height, &stride);
EsAssert(stride == width * 4); // TODO Other strides.
SwapRedAndBlueChannels(bits, width, height, stride); // stbi_write uses the other order. We swap back below.
size_t _bufferBytes = 262144;
uint8_t *_buffer = (uint8_t *) EsHeapAllocate(_bufferBytes, false);
EsBuffer buffer = { .out = _buffer, .bytes = _bufferBytes };
buffer.fileStore = message->instanceSave.file;
EsUniqueIdentifier typeJPG = (EsUniqueIdentifier)
{{ 0xD8, 0xC2, 0x13, 0xB0, 0x53, 0x64, 0x82, 0x11, 0x48, 0x7B, 0x5B, 0x64, 0x0F, 0x92, 0xB9, 0x38 }};
EsUniqueIdentifier typeBMP = (EsUniqueIdentifier)
{{ 0x40, 0x15, 0xB7, 0x82, 0x99, 0x6D, 0xD5, 0x41, 0x96, 0xD5, 0x3B, 0x6D, 0xA6, 0x5F, 0x07, 0x34 }};
EsUniqueIdentifier typeTGA = (EsUniqueIdentifier)
{{ 0x69, 0x62, 0x4E, 0x28, 0xA1, 0xE1, 0x7B, 0x35, 0x64, 0x2E, 0x36, 0x01, 0x65, 0x91, 0xBE, 0xA1 }};
EsUniqueIdentifier typePNG = (EsUniqueIdentifier)
{{ 0x59, 0x21, 0x05, 0x4D, 0x34, 0x40, 0xAB, 0x61, 0xEC, 0xF9, 0x7D, 0x5C, 0x6E, 0x04, 0x96, 0xAE }};
if (0 == EsStringCompare(extension, extensionBytes, EsLiteral("jpg"))
|| 0 == EsStringCompare(extension, extensionBytes, EsLiteral("jpeg"))) {
EsFileStoreSetContentType(message->instanceSave.file, typeJPG);
stbi_write_jpg_to_func(WriteCallback, &buffer, width, height, 4, bits, 90);
} else if (0 == EsStringCompare(extension, extensionBytes, EsLiteral("bmp"))) {
EsFileStoreSetContentType(message->instanceSave.file, typeBMP);
stbi_write_bmp_to_func(WriteCallback, &buffer, width, height, 4, bits);
} else if (0 == EsStringCompare(extension, extensionBytes, EsLiteral("tga"))) {
EsFileStoreSetContentType(message->instanceSave.file, typeTGA);
stbi_write_tga_to_func(WriteCallback, &buffer, width, height, 4, bits);
} else {
EsFileStoreSetContentType(message->instanceSave.file, typePNG);
stbi_write_png_to_func(WriteCallback, &buffer, width, height, 4, bits, stride);
}
SwapRedAndBlueChannels(bits, width, height, stride); // Swap back.
EsBufferFlushToFileStore(&buffer);
EsHeapFree(_buffer);
EsPaintTargetEndDirectAccess(instance->bitmap);
EsInstanceSaveComplete(instance, message->instanceSave.file, true);
} else if (message->type == ES_MSG_INSTANCE_OPEN) {
size_t fileSize;
uint8_t *file = (uint8_t *) EsFileStoreReadAll(message->instanceOpen.file, &fileSize);
if (!file) {
EsInstanceOpenComplete(instance, message->instanceOpen.file, false);
return ES_HANDLED;
}
uint32_t width, height;
uint8_t *bits = EsImageLoad(file, fileSize, &width, &height, 4);
EsHeapFree(file);
if (!bits) {
EsInstanceOpenComplete(instance, message->instanceOpen.file, false, INTERFACE_STRING(ImageEditorUnsupportedFormat));
return ES_HANDLED;
}
EsPaintTargetDestroy(instance->bitmap);
ImageDelete(instance->image);
instance->bitmapWidth = width;
instance->bitmapHeight = height;
instance->bitmap = EsPaintTargetCreate(instance->bitmapWidth, instance->bitmapHeight, false);
EsPainter painter = {};
painter.clip = ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight);
painter.target = instance->bitmap;
EsDrawBitmap(&painter, painter.clip, (uint32_t *) bits, width * 4, 0xFF);
instance->image = ImageFork(instance, {}, instance->bitmapWidth, instance->bitmapHeight);
ImageCopyFromPaintTarget(instance, &instance->image, painter.clip);
EsElementRelayout(EsElementGetLayoutParent(instance->canvas));
EsHeapFree(bits);
EsInstanceOpenComplete(instance, message->instanceOpen.file, true);
} else {
return 0;
}
return ES_HANDLED;
}
void InstanceCreate(EsMessage *message) {
Instance *instance = EsInstanceCreate(message, INTERFACE_STRING(ImageEditorTitle));
instance->callback = InstanceCallback;
EsElement *toolbar = EsWindowGetToolbar(instance->window);
EsInstanceSetClassEditor(instance, &editorSettings);
// Register commands.
EsCommandRegister(&instance->commandBrush, instance, INTERFACE_STRING(ImageEditorToolBrush), CommandSelectTool, 1, "N", true);
EsCommandRegister(&instance->commandFill, instance, INTERFACE_STRING(ImageEditorToolFill), CommandSelectTool, 2, "Shift+B", true);
EsCommandRegister(&instance->commandRectangle, instance, INTERFACE_STRING(ImageEditorToolRectangle), CommandSelectTool, 3, "Shift+R", true);
EsCommandRegister(&instance->commandSelect, instance, INTERFACE_STRING(ImageEditorToolSelect), CommandSelectTool, 4, "R", false);
EsCommandRegister(&instance->commandText, instance, INTERFACE_STRING(ImageEditorToolText), CommandSelectTool, 5, "T", false);
EsCommandSetCheck(&instance->commandBrush, ES_CHECK_CHECKED, false);
// Create the toolbar.
EsButton *button;
EsFileMenuAddToToolbar(toolbar);
button = EsButtonCreate(toolbar, ES_BUTTON_DROPDOWN, ES_STYLE_PUSH_BUTTON_TOOLBAR, INTERFACE_STRING(ImageEditorImage));
EsButtonSetIcon(button, ES_ICON_IMAGE_X_GENERIC);
button->accessKey = 'I';
EsButtonOnCommand(button, MenuImage);
EsPanel *buttonGroup = EsPanelCreate(toolbar, ES_PANEL_HORIZONTAL | ES_ELEMENT_AUTO_GROUP);
button = EsButtonCreate(buttonGroup);
EsCommandAddButton(EsCommandByID(instance, ES_COMMAND_UNDO), button);
EsButtonSetIcon(button, ES_ICON_EDIT_UNDO_SYMBOLIC);
button->accessKey = 'U';
EsSpacerCreate(buttonGroup, ES_CELL_V_FILL, ES_STYLE_TOOLBAR_BUTTON_GROUP_SEPARATOR);
button = EsButtonCreate(buttonGroup);
EsCommandAddButton(EsCommandByID(instance, ES_COMMAND_REDO), button);
EsButtonSetIcon(button, ES_ICON_EDIT_REDO_SYMBOLIC);
button->accessKey = 'R';
EsSpacerCreate(toolbar, ES_CELL_FILL);
button = instance->toolDropdown = EsButtonCreate(toolbar, ES_BUTTON_DROPDOWN,
ES_STYLE_PUSH_BUTTON_TOOLBAR_BIG, INTERFACE_STRING(ImageEditorPickTool));
EsButtonSetIcon(button, ES_ICON_DRAW_FREEHAND);
EsButtonOnCommand(button, MenuTools);
button->accessKey = 'T';
instance->toolPanel = EsPanelCreate(toolbar, ES_PANEL_HORIZONTAL | ES_ELEMENT_AUTO_GROUP);
button = EsButtonCreate(instance->toolPanel, ES_FLAGS_DEFAULT, ES_STYLE_PUSH_BUTTON_TOOLBAR_BIG, INTERFACE_STRING(ImageEditorToolBrush));
EsCommandAddButton(&instance->commandBrush, button);
EsButtonSetIcon(button, ES_ICON_DRAW_FREEHAND);
button->accessKey = 'B';
EsSpacerCreate(instance->toolPanel, ES_CELL_V_FILL, ES_STYLE_TOOLBAR_BUTTON_GROUP_SEPARATOR);
button = EsButtonCreate(instance->toolPanel, ES_FLAGS_DEFAULT, ES_STYLE_PUSH_BUTTON_TOOLBAR_BIG, INTERFACE_STRING(ImageEditorToolFill));
EsCommandAddButton(&instance->commandFill, button);
EsButtonSetIcon(button, ES_ICON_COLOR_FILL);
button->accessKey = 'F';
EsSpacerCreate(instance->toolPanel, ES_CELL_V_FILL, ES_STYLE_TOOLBAR_BUTTON_GROUP_SEPARATOR);
button = EsButtonCreate(instance->toolPanel, ES_FLAGS_DEFAULT, ES_STYLE_PUSH_BUTTON_TOOLBAR_BIG, INTERFACE_STRING(ImageEditorToolRectangle));
EsCommandAddButton(&instance->commandRectangle, button);
EsButtonSetIcon(button, ES_ICON_DRAW_RECTANGLE);
button->accessKey = 'E';
EsSpacerCreate(instance->toolPanel, ES_CELL_V_FILL, ES_STYLE_TOOLBAR_BUTTON_GROUP_SEPARATOR);
button = EsButtonCreate(instance->toolPanel, ES_FLAGS_DEFAULT, ES_STYLE_PUSH_BUTTON_TOOLBAR_BIG, INTERFACE_STRING(ImageEditorToolSelect));
EsCommandAddButton(&instance->commandSelect, button);
EsButtonSetIcon(button, ES_ICON_OBJECT_GROUP);
button->accessKey = 'S';
EsSpacerCreate(instance->toolPanel, ES_CELL_V_FILL, ES_STYLE_TOOLBAR_BUTTON_GROUP_SEPARATOR);
button = EsButtonCreate(instance->toolPanel, ES_FLAGS_DEFAULT, ES_STYLE_PUSH_BUTTON_TOOLBAR_BIG, INTERFACE_STRING(ImageEditorToolText));
EsCommandAddButton(&instance->commandText, button);
EsButtonSetIcon(button, ES_ICON_DRAW_TEXT);
button->accessKey = 'T';
EsWindowAddSizeAlternative(instance->window, instance->toolDropdown, instance->toolPanel, 1100, 0);
EsSpacerCreate(toolbar, ES_CELL_FILL);
EsPanel *section = EsPanelCreate(toolbar, ES_PANEL_HORIZONTAL);
EsTextDisplayCreate(section, ES_FLAGS_DEFAULT, 0, INTERFACE_STRING(ImageEditorPropertyColor));
instance->colorWell = EsColorWellCreate(section, ES_FLAGS_DEFAULT, 0xFFFF0000);
instance->colorWell->accessKey = 'C';
EsSpacerCreate(toolbar, ES_FLAGS_DEFAULT, 0, 5, 0);
section = EsPanelCreate(toolbar, ES_PANEL_HORIZONTAL);
EsTextDisplayCreate(section, ES_FLAGS_DEFAULT, 0, INTERFACE_STRING(ImageEditorPropertyBrushSize));
instance->brushSize = EsTextboxCreate(section, ES_TEXTBOX_EDIT_BASED, ES_STYLE_TEXTBOX_BORDERED_SINGLE_COMPACT);
instance->brushSize->messageUser = BrushSizeMessage;
EsTextboxUseNumberOverlay(instance->brushSize, false);
EsTextboxInsert(instance->brushSize, EsLiteral("5.0"));
instance->brushSize->accessKey = 'Z';
EsSpacerCreate(toolbar, ES_FLAGS_DEFAULT, 0, 1, 0);
// Create the user interface.
EsWindowSetIcon(instance->window, ES_ICON_MULTIMEDIA_PHOTO_MANAGER);
EsCanvasPane *canvasPane = EsCanvasPaneCreate(instance->window, ES_CELL_FILL | ES_CANVAS_PANE_SHOW_SHADOW, ES_STYLE_PANEL_WINDOW_BACKGROUND);
instance->canvas = EsCustomElementCreate(canvasPane, ES_CELL_CENTER | ES_ELEMENT_FOCUSABLE);
instance->canvas->messageUser = CanvasMessage;
EsElementFocus(instance->canvas, false);
// Setup the paint target and the image.
instance->bitmapWidth = 500;
instance->bitmapHeight = 400;
instance->bitmap = EsPaintTargetCreate(instance->bitmapWidth, instance->bitmapHeight, false);
EsPainter painter = {};
painter.clip = ES_RECT_4(0, instance->bitmapWidth, 0, instance->bitmapHeight);
painter.target = instance->bitmap;
EsDrawBlock(&painter, painter.clip, 0xFFFFFFFF);
instance->image = ImageFork(instance, {}, instance->bitmapWidth, instance->bitmapHeight);
ImageCopyFromPaintTarget(instance, &instance->image, painter.clip);
}
void _start() {
_init();
while (true) {
EsMessage *message = EsMessageReceive();
if (message->type == ES_MSG_INSTANCE_CREATE) {
InstanceCreate(message);
}
}
}
View Git Blame Copy Permalink