Preview zoom scales with window size, listed view scale doesn't change.

Panning doesn't seem to be happinging in screen space so when zoomed it doesn't track intuitively with mouse cursor.

Being able to zoom out below 100% then zoom at mouse cursor would be handy for navigating large images.

Mousewheel zoom with MMB pan would be nice.

Here's the relevant code from one of my projects for mouse-view-transform-as-I-like-it, feel free to steal (QTransform is just a 3X3 transform matrix):

void ImageEditor::rotateScaleAtPoint(QTransform &transform, const qreal rotation, const qreal scaling, const QPointF point)
{
const QPointF pointBefore = (transform.inverted()).map(point);
transform *= QTransform().scale(scaling, scaling) * QTransform().rotate(rotation);
const QPointF pointAfter = (transform.inverted()).map(point);
const QPointF offset = pointAfter - pointBefore;
transform = QTransform().translate(offset.x(), offset.y()) * transform;
}

bool ImageEditor::handleMouseEvent(const Qt::KeyboardModifiers modifiers, const Qt::MouseButton button, const QPoint pos)
{
const QPointF lastMouse = mouseTransform.map(lastMousePos);
const QPointF mousePos = mouseTransform.map(pos);
const QPointF pixelCoordF = viewTransform.inverted().map(QPointF(mousePos));
const QPoint pixelCoord(static_cast(floor(pixelCoordF.x())), static_cast(floor(pixelCoordF.y())));

const QSet states = mouseState.machine.configuration();
if (states.contains(&mouseState.leftToolState)) {
setDocumentModified();
}
else if (states.contains(&mouseState.leftPickState)) {
}
else if (states.contains(&mouseState.rightToolState)) {
}
else if (states.contains(&mouseState.rightPickState)) {
}
else if (states.contains(&mouseState.panState)) {
QPointF translation = QPointF();
translation += mousePos - lastMouse;
viewTransform *= QTransform().translate(translation.x(), translation.y());
update();
}
else if (states.contains(&mouseState.rotozoomState)) {
qreal scaling = QVector2D(mousePos).length() / QVector2D(lastMouse).length();
qreal rotation = qRadiansToDegrees(atan2(mousePos.y(), mousePos.x()) - atan2(lastMouse.y(), lastMouse.x()));
rotateScaleAtPoint(viewTransform, rotation, scaling, QPointF(0., 0.));
update();
}

lastMousePos = pos;
lastPixelCoord = pixelCoord;

return true;
}

void ImageEditor::wheelEvent(QWheelEvent *event)
{
const qreal delta = event->angleDelta().y() / (15.0 * 8.0);
const qreal scaling = pow(2, delta);
const qreal rotation = -15.0 * delta;

if (event->modifiers() == Qt::NoModifier) {
rotateScaleAtPoint(viewTransform, 0.0, scaling, mouseTransform.map(event->posF()));
update();
}
else if (event->modifiers() == Qt::ShiftModifier) {
rotateScaleAtPoint(viewTransform, rotation, 1.0, mouseTransform.map(event->posF()));
update();
}
event->accept();
}

Runs fine in Wine with the exception of file dialogs appearing behing the main window.

If you don't work with indices then you can't really work with images with subpalettes (NES, SMS, MD, GBC, etc.). If two subpalettes contain the same colour then they'll both be changed.
Working with RGB values could still be useful especially with a similarity threshold for higher colour images.
An option to select between indexed and RGB working modes would be nice.

Preview functionality could be improved considerably.
I figured picking the index from the preview was a given.
Large image is scaled to less than 1x so I can't see individual pixels. Being able to freely zoom and pan preview is a must.

Be nice is there was an option to use the target palette as the destination palette when an image is loaded so it doesn't need to be loaded again seperately.

Your link to the demo tries to connect to localhost.

Awesome stuff again.

Looks good.

For me to be bothered to use something like this outside of the editor it would need to perform many different mappings on different areas of the same image. eg. If I want to do 8 colour variations of a sprite, I duplicate the sprite 8 times in the source file, open it in your tool, select the first copy, fiddle with the colours, select the next copy, fiddle with the colours and so on.

Being able to create new colours is important, rather than being limited to a pre-existing palette.

A nice feature for larger gradient-based palettes would be support for gradient-to-gradient mappings. So mark a sequence on the source palette and a sequence of the destination palette then intepolated the one to the other. Be much easier than individually marking each colour on a large palette and allow adapting between different gradient sizes.

AFAIK the Pixel Joint forums are the original home of DB's palettes.