hrynco/hrynco-kswitcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 41 Wiki Activity

Release v0.6.24: smart shapes, rotation and canvas zoom

Browse Source
This commit is contained in:
Anatolii Hrynchuk
2026-11-01 22:25:15 +02:00
parent 9b231146cb
commit 20f3b72287
12 changed files with 842 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/screenshot_ui.cpp
+210
View File
@@ -2,10 +2,12 @@
// Including the implementation lets this integration test drive private editor state directly.
#include "../src/screenshot.cpp"
#include <iostream>
#include "stroke_improvement.h"
int main(int argc, char **argv)
{
CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
try {
testStrokeImprovement();
if(argc>1 && std::string(argv[1])=="--save-only") {
auto require=[](bool ok,const char *message){if(!ok) throw std::runtime_error(message);};
auto root=std::filesystem::temp_directory_path()/(L"KSwitcher-save-"+std::to_wstring(GetCurrentProcessId()));
@@ -81,6 +83,169 @@ int main(int argc, char **argv)
require(c.pencilCursor!=nullptr,"pencil drawing cursor loads");
require(c.freehand && !c.pointer && ks::toolCursor(c)==c.pencilCursor,
"new screenshot editor starts with the pencil tool");
{
require(GetDlgItem(window,36)!=nullptr,"triangle has a dedicated toolbar button");
SendMessageW(window,WM_KEYDOWN,'G',0);
require(c.shape==ks::ScreenshotShape::Triangle && c.arrow && !c.freehand,"G selects triangle drawing tool");
auto mouse=[&](UINT message,POINT p) {
int x=c.view.left+MulDiv(p.x,c.view.right-c.view.left,c.image->width);
int y=c.view.top+MulDiv(p.y,c.view.bottom-c.view.top,c.image->height);
SendMessageW(window,message,message==WM_LBUTTONUP?0:MK_LBUTTON,MAKELPARAM(x,y));
};
mouse(WM_LBUTTONDOWN,{80,80}); mouse(WM_LBUTTONUP,{220,180});
require(c.marks.size()==1 && c.marks[0].shape==ks::ScreenshotShape::Triangle && c.marks[0].points.size()==4,
"triangle tool creates a closed three-vertex shape");
auto triangle=c.marks[0];
for(double angle:{0.0,37.0,90.0,-125.0}) for(int i=0;i<3;++i) {
auto original=triangle; original.rotation=angle;
auto vertices=ks::shapeOutline(original);
auto part=ks::MarkPart(int(ks::MarkPart::Vertex0)+i);
require(ks::hitScreenshotMark(original,vertices[i],4)==part,"each rotated triangle vertex has its own handle");
POINT target{vertices[i].x+13,vertices[i].y-9};
auto changed=ks::dragScreenshotMark(original,part,vertices[i],target,320,240);
auto moved=ks::shapeOutline(changed);
for(int j=0;j<3;++j) {
auto expected=j==i?target:vertices[j];
require(std::abs(moved[j].x-expected.x)<=2 && std::abs(moved[j].y-expected.y)<=2,
"dragging one vertex preserves both other world vertices after rotation");
}
require(changed.points.front().x==changed.points.back().x && changed.points.front().y==changed.points.back().y,
"triangle remains closed after editing any vertex");
}
auto vertices=ks::shapeOutline(triangle);
mouse(WM_LBUTTONDOWN,vertices[0]);
require(c.part==ks::MarkPart::Vertex0,"mouse selects apex vertex");
mouse(WM_LBUTTONUP,{vertices[0].x+20,vertices[0].y+10});
require(c.marks[0].points[0].x==triangle.points[0].x+20 && c.marks[0].points[1].x==triangle.points[1].x,
"mouse vertex drag changes only requested corner");
SendMessageW(window,WM_COMMAND,12,0);
require(c.marks[0].points[0].x==triangle.points[0].x,"undo restores triangle vertex");
SendMessageW(window,WM_COMMAND,18,0);
require(c.marks[0].points[0].x==triangle.points[0].x+20,"redo reapplies triangle vertex edit");
c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
require(GetDlgItem(window,37)!=nullptr,"trapezoid has a dedicated toolbar button");
SendMessageW(window,WM_KEYDOWN,'B',0);
require(c.shape==ks::ScreenshotShape::Trapezoid && c.arrow && !c.freehand,"B selects trapezoid tool");
mouse(WM_LBUTTONDOWN,{60,70}); mouse(WM_LBUTTONUP,{240,180});
require(c.marks.size()==1 && c.marks[0].shape==ks::ScreenshotShape::Trapezoid && c.marks[0].points.size()==5 && !c.marks[0].isHighlight(),
"trapezoid tool creates a closed shape with unequal parallel bases");
auto trapezoid=c.marks[0];
require(trapezoid.points[0].y==trapezoid.points[1].y && trapezoid.points[2].y==trapezoid.points[3].y &&
trapezoid.points[1].x-trapezoid.points[0].x<trapezoid.points[2].x-trapezoid.points[3].x,"toolbar trapezoid has parallel unequal bases");
mouse(WM_LBUTTONDOWN,trapezoid.to); mouse(WM_LBUTTONUP,{260,200});
require(c.marks[0].to.x==260 && c.marks[0].points[0].y==c.marks[0].points[1].y,"trapezoid resizes as a shape");
auto grip=ks::screenshotShapeRotationHandle(c.marks[0]);
auto rotated=ks::dragScreenshotMark(c.marks[0],ks::MarkPart::Rotation,grip,{280,135},320,240);
require(rotated.rotation!=0 && rotated.shape==ks::ScreenshotShape::Trapezoid,"trapezoid supports shape rotation");
SendMessageW(window,WM_COMMAND,12,0); require(c.marks[0].to.x==240,"undo trapezoid resize");
SendMessageW(window,WM_COMMAND,12,0); require(c.marks.empty(),"undo trapezoid creation");
SendMessageW(window,WM_COMMAND,18,0); require(c.marks[0].shape==ks::ScreenshotShape::Trapezoid,"redo trapezoid creation");
c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
SendMessageW(window,WM_COMMAND,21,0);
}
{
for(auto kind:{ks::ScreenshotShape::Rectangle,ks::ScreenshotShape::Circle,ks::ScreenshotShape::Ellipse,ks::ScreenshotShape::Triangle})
for(bool recognized:{false,true}) {
if(kind==ks::ScreenshotShape::Triangle && !recognized) continue;
ks::Mark shape{{100,90},{200,170},0}; shape.shape=kind; shape.ends=ks::LineEnds::None;
if(kind==ks::ScreenshotShape::Circle) shape.to.y=190;
if(recognized) shape.points=kind==ks::ScreenshotShape::Triangle?
std::vector<POINT>{{150,90},{200,170},{100,170},{150,90}}:ks::shapeOutline(shape);
auto grip=ks::screenshotShapeRotationHandle(shape);
POINT center{(shape.from.x+shape.to.x)/2,(shape.from.y+shape.to.y)/2};
POINT right{center.x+center.y-grip.y,center.y};
auto rotated=ks::dragScreenshotMark(shape,ks::MarkPart::Rotation,grip,right,320,240);
require(std::abs(rotated.rotation-90)<.01 && rotated.from.x==shape.from.x && rotated.to.y==shape.to.y,
"all native and recognized shapes rotate around their center");
auto corner=ks::rotateShapePoint(rotated,rotated.to);
require(ks::hitScreenshotMark(rotated,corner,4)==(kind==ks::ScreenshotShape::Triangle?ks::MarkPart::Vertex1:ks::MarkPart::End),"rotated resize handles remain hittable");
auto fixed=ks::rotateShapePoint(rotated,rotated.from);
auto resized=ks::dragScreenshotMark(rotated,ks::MarkPart::End,corner,{corner.x-15,corner.y+20},320,240);
auto stillFixed=ks::rotateShapePoint(resized,resized.from);
require(std::abs(stillFixed.x-fixed.x)<=1 && std::abs(stillFixed.y-fixed.y)<=1 && resized.rotation==90,
"resizing rotated shapes keeps the opposite world corner fixed");
auto snapped=ks::dragScreenshotMark(shape,ks::MarkPart::Rotation,grip,{center.x+60,center.y-20},320,240,true);
require(std::abs(std::remainder(snapped.rotation,15))<.01,"Shift snaps shape rotation to 15 degrees");
auto cloned=ks::cloneScreenshotMark(rotated,{rotated},320,240);
require(cloned.rotation==rotated.rotation && cloned.shape==kind,"clone preserves shape rotation");
auto boundary=ks::shapeOutline(shape).front();
std::vector<ks::Mark> linked{shape,{{20,20},boundary,0}};
ks::linkScreenshotEndpoint(linked[1],false,boundary,linked,4);
require(linked[1].toLink.target!=0,"connector attaches to shape before rotation");
linked[0].rotation=90; ks::resolveScreenshotLinks(linked);
auto expected=ks::rotateShapePoint(linked[0],boundary);
require(std::abs(linked[1].to.x-expected.x)<=1 && std::abs(linked[1].to.y-expected.y)<=1,
"connector follows rotated shape boundary");
}
ks::Mark shape{{100,90},{200,170},0}; shape.shape=ks::ScreenshotShape::Rectangle;
c.marks={shape}; c.selected=0;
auto mouse=[&](UINT message,POINT p) {
auto x=c.view.left+MulDiv(p.x,c.view.right-c.view.left,c.image->width);
auto y=c.view.top+MulDiv(p.y,c.view.bottom-c.view.top,c.image->height);
SendMessageW(window,message,message==WM_LBUTTONUP?0:MK_LBUTTON,MAKELPARAM(x,y));
};
auto grip=ks::screenshotShapeRotationHandle(shape,double(c.unit)*c.image->width/(c.view.right-c.view.left));
require(ks::markAt(c,grip).second==ks::MarkPart::Rotation,"shape rotation grip is distinct from thickness grip");
mouse(WM_LBUTTONDOWN,grip); mouse(WM_LBUTTONUP,{150+130-grip.y,130});
require(std::abs(c.marks[0].rotation-90)<1,"mouse rotation updates selected shape");
SendMessageW(window,WM_COMMAND,12,0); require(c.marks[0].rotation==0,"undo restores original shape orientation");
SendMessageW(window,WM_COMMAND,18,0); require(std::abs(c.marks[0].rotation-90)<1,"redo restores shape rotation");
c.selected=0;
ks::Surface rotatedPixels(320,240); PatBlt(rotatedPixels.dc,0,0,320,240,WHITENESS);
auto rendered=ks::decodeImage(ks::screenshotClip(rotatedPixels.dc,320,240,c.marks));
auto pixel=(100*320+190)*4;
require(rendered.bgra[pixel+2]==GetRValue(shape.color) && rendered.bgra[pixel+1]==GetGValue(shape.color),
"export renders rotated shape at its new boundary");
POINT center{(c.canvas.left+c.canvas.right)/2,(c.canvas.top+c.canvas.bottom)/2};
ks::zoomCanvas(window,c,2,center);
grip=ks::screenshotShapeRotationHandle(c.marks[0],double(c.unit)*c.image->width/(c.view.right-c.view.left));
require(ks::markAt(c,grip).second==ks::MarkPart::Rotation,"rotation grip works on zoomed canvas");
ks::zoomCanvas(window,c,1,center,true);
c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
}
{
BYTE savedKeys[256]{},keys[256]{}; GetKeyboardState(savedKeys);
std::copy(savedKeys,savedKeys+256,keys); keys[VK_CONTROL]=0x80; SetKeyboardState(keys);
auto fit=c.view;
SendMessageW(window,WM_KEYDOWN,VK_OEM_PLUS,0);
require(c.zoom==1.25 && c.view.right-c.view.left>fit.right-fit.left,"Ctrl+plus zooms canvas");
SendMessageW(window,WM_KEYDOWN,VK_SUBTRACT,0);
require(std::abs(c.zoom-1)<.001,"Ctrl+numpad minus zooms out");
SendMessageW(window,WM_KEYDOWN,VK_ADD,0);
SendMessageW(window,WM_KEYDOWN,VK_OEM_MINUS,0);
require(std::abs(c.zoom-1)<.001,"both keyboard plus/minus variants work");
POINT center{(c.canvas.left+c.canvas.right)/2,(c.canvas.top+c.canvas.bottom)/2};
ks::zoomCanvas(window,c,4,center);
POINT anchor{center.x+12,center.y+8},screen=anchor; ClientToScreen(window,&screen);
auto before=ks::imagePoint(c,anchor,false); double zoom=c.zoom;
SendMessageW(window,WM_MOUSEWHEEL,MAKEWPARAM(MK_CONTROL,60),MAKELPARAM(screen.x,screen.y));
require(c.zoom==zoom,"partial wheel delta waits for a full step");
SendMessageW(window,WM_MOUSEWHEEL,MAKEWPARAM(MK_CONTROL,60),MAKELPARAM(screen.x,screen.y));
auto after=ks::imagePoint(c,anchor,false);
require(c.zoom>zoom && std::abs(before.x-after.x)<=1 && std::abs(before.y-after.y)<=1,
"Ctrl+wheel zoom keeps image point under cursor");
require(!c.history.canUndo(),"zoom does not add image edits to undo history");
auto view=c.view;
SendMessageW(window,WM_MBUTTONDOWN,MK_MBUTTON,MAKELPARAM(center.x,center.y));
SendMessageW(window,WM_MOUSEMOVE,MK_MBUTTON,MAKELPARAM(center.x+15,center.y+10));
SendMessageW(window,WM_MBUTTONUP,0,MAKELPARAM(center.x+15,center.y+10));
require(c.view.left==view.left+15 && c.view.top==view.top+10 && !c.panning,"middle drag pans enlarged canvas");
keys[VK_CONTROL]=0; SetKeyboardState(keys);
auto a=ks::imagePoint(c,center),b=ks::imagePoint(c,{center.x+30,center.y+20});
SendMessageW(window,WM_LBUTTONDOWN,MK_LBUTTON,MAKELPARAM(center.x,center.y));
SendMessageW(window,WM_LBUTTONUP,0,MAKELPARAM(center.x+30,center.y+20));
require(c.marks.size()==1 && c.marks[0].from.x==a.x && c.marks[0].to.x==b.x && c.marks[0].to.y==b.y,
"drawing after zoom and pan uses image coordinates");
auto original=c.marks[0];
keys[VK_CONTROL]=0x80; SetKeyboardState(keys);
SendMessageW(window,WM_KEYDOWN,'0',0);
require(c.zoom==1 && c.panX==0 && c.panY==0 && c.marks[0].from.x==original.from.x && c.marks[0].to.x==original.to.x,
"Ctrl+0 resets view without transforming annotations");
ks::zoomCanvas(window,c,1e6,center); require(c.zoom==16,"zoom has upper bound");
ks::zoomCanvas(window,c,1e-6,center); require(c.zoom==.1,"zoom has lower bound");
SendMessageW(window,WM_KEYDOWN,'0',0); SetKeyboardState(savedKeys);
c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
}
{
BYTE savedKeys[256]{},keys[256]{}; GetKeyboardState(savedKeys);
std::copy(savedKeys,savedKeys+256,keys); keys[VK_SHIFT]=0; SetKeyboardState(keys);
@@ -89,6 +254,51 @@ int main(int argc, char **argv)
int y=c.view.top+MulDiv(p.y,c.view.bottom-c.view.top,c.image->height);
SendMessageW(window,message,(message==WM_LBUTTONUP?0:MK_LBUTTON)|(shift?MK_SHIFT:0),MAKELPARAM(x,y));
};
mouse(WM_LBUTTONDOWN,{30,190});
for(int x=35;x<=200;x+=5) mouse(WM_MOUSEMOVE,{x,190+(x%10?2:-2)});
auto original=c.stroke.points;
mouse(WM_LBUTTONUP,c.stroke.to);
require(c.marks.size()==1,"improved stroke is one object");
auto improved=c.marks.back().points;
SendMessageW(window,WM_COMMAND,12,0);
require(c.marks.size()==1 && c.marks.back().points.size()==original.size() &&
std::equal(original.begin(),original.end(),c.marks.back().points.begin(),
[](POINT a,POINT b){return a.x==b.x && a.y==b.y;}),"first undo restores exact raw stroke");
SendMessageW(window,WM_COMMAND,12,0);
require(c.marks.empty(),"second undo removes stroke");
SendMessageW(window,WM_COMMAND,18,0); SendMessageW(window,WM_COMMAND,18,0);
require(c.marks.size()==1 && c.marks.back().points.size()==improved.size(),"redo restores improvement");
c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
mouse(WM_LBUTTONDOWN,{180,120});
for(int i=1;i<=120;++i) {
double a=i*2*3.141592653589793/120;
mouse(WM_MOUSEMOVE,{LONG(std::lround(130+50*std::cos(a))),LONG(std::lround(120+50*std::sin(a)))});
}
mouse(WM_LBUTTONUP,c.stroke.to);
require(c.marks.size()==1 && c.marks[0].shape==ks::ScreenshotShape::Circle &&
!c.marks[0].freehand && !c.marks[0].isHighlight(),"recognized circle is a shape, not a pencil or highlight");
auto circle=c.marks[0];
require(ks::hitScreenshotMark(circle,circle.to,6)==ks::MarkPart::End,"recognized shape exposes bounding-box resize handle");
mouse(WM_LBUTTONDOWN,circle.to);
mouse(WM_MOUSEMOVE,{circle.to.x+30,circle.to.y+20});
mouse(WM_LBUTTONUP,{circle.to.x+30,circle.to.y+20});
require(c.marks[0].to.x>circle.to.x && c.marks[0].to.x-c.marks[0].from.x==c.marks[0].to.y-c.marks[0].from.y &&
c.marks[0].points[0].x>circle.points[0].x,"dragging recognized circle handle scales the whole circle proportionally");
SendMessageW(window,WM_COMMAND,12,0);
require(c.marks[0].shape==ks::ScreenshotShape::Circle && c.marks[0].to.x==circle.to.x,"undo restores shape size");
SendMessageW(window,WM_COMMAND,12,0);
require(c.marks[0].freehand && c.marks[0].shape==ks::ScreenshotShape::None,"undo recognition restores editable pencil stroke");
SendMessageW(window,WM_COMMAND,18,0);
require(c.marks[0].shape==ks::ScreenshotShape::Circle,"redo restores shape type");
for(auto kind:{ks::ScreenshotShape::Rectangle,ks::ScreenshotShape::Ellipse,ks::ScreenshotShape::Triangle}) {
auto shape=circle; shape.shape=kind;
auto resized=ks::dragScreenshotMark(shape,ks::MarkPart::End,shape.to,{shape.to.x+50,shape.to.y+20},320,240);
require(resized.points[0].x!=shape.points[0].x && resized.points[24].y!=shape.points[24].y,
"shape resize transforms all outline points in both axes");
auto moved=ks::cloneScreenshotMark(resized,{resized},320,240);
require(moved.shape==kind && !moved.isHighlight(),"clone preserves recognized shape type");
}
c.marks.clear(); c.selected=-1; c.history=ks::ScreenshotHistory{};
mouse(WM_LBUTTONDOWN,{40,40},true);
mouse(WM_MOUSEMOVE,{100,50},true);
require(c.stroke.to.x==100 && c.stroke.to.y==40,"Shift constrains pencil horizontally");