hrynco/hrynco-kswitcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 45 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
src/screenshot.cpp
+271 -34
View File
@@ -1,4 +1,5 @@
#include "screenshot.h"
#include "stroke_improvement.h"
#include "ocr.h"
#include "../resources/resource.h"
#include <algorithm>
@@ -53,7 +54,7 @@ bool confirmScreenshotClose(HWND owner)
// If Windows cannot display the confirmation, keep the screenshot open.
return SUCCEEDED(result) && button==IDYES;
}
constexpr int ToolIds[]{27,10,11,22,23,24,25,21,19,26,20,12,18,13};
constexpr int ToolIds[]{27,10,11,22,23,24,25,36,37,21,19,26,20,12,18,13};
struct Surface
{
HDC dc = CreateCompatibleDC(nullptr);
@@ -123,7 +124,7 @@ bool chooseTextFont(HWND owner,Mark &m)
m.fontWeight=font.lfWeight; m.fontItalic=font.lfItalic!=0;
return true;
}
constexpr int CursorTools[]{10,11,22,23,24,25,19};
constexpr int CursorTools[]{10,11,22,23,24,25,36,37,19};
HCURSOR makeToolCursor(int tool,int size)
{
// Monochrome AND/XOR cursor: white outline keeps the glyph visible on dark images.
@@ -148,6 +149,8 @@ HCURSOR makeToolCursor(int tool,int size)
case 23: Rectangle(dc,x(17),y(18),x(30),y(29)); break;
case 24: Ellipse(dc,x(17),y(17),x(30),y(30)); break;
case 25: Ellipse(dc,x(16),y(20),x(31),y(28)); break;
case 36: { POINT p[]{{x(23),y(17)},{x(31),y(30)},{x(16),y(30)},{x(23),y(17)}}; Polyline(dc,p,4); break; }
case 37: { POINT p[]{{x(20),y(18)},{x(27),y(18)},{x(31),y(30)},{x(16),y(30)},{x(20),y(18)}}; Polyline(dc,p,5); break; }
case 19:
line(18,25,25,18); line(25,18,29,22); line(29,22,22,29);
line(22,29,18,25); line(18,25,17,30); line(17,30,22,29); break;
@@ -179,12 +182,18 @@ struct Capture
COLORREF customColors[16]{};
Mark stroke{};
bool strokeConstrained{};
bool strokeUsedConstraint{};
size_t strokeAnchor{};
int strokeAxis{}; // 0 = not chosen, 1 = horizontal, 2 = vertical, 3/4 = diagonals.
bool strokeAxisSettled{};
std::vector<POINT> strokeMotion;
POINT start{}, end{};
RECT selection{}, view{};
RECT canvas{};
double zoom=1,panX=0,panY=0;
bool panning=false;
POINT panOrigin{};
int zoomWheelDelta=0;
std::vector<Mark> marks;
ScreenshotHistory history;
HWND editor{}, inlineText{};
@@ -243,9 +252,10 @@ void updateStatus(Capture &c)
if(c.hoveredTool==28) text=L"Save (Ctrl+S) | Save As... (Ctrl+Shift+S)";
}
else if(c.inlineText) text=L"Text: Enter = new line | Ctrl+Enter = apply | Esc = cancel";
else if(part==MarkPart::Rotation) text=L"Drag to rotate text | Hold Shift for 15-degree steps";
else if(part==MarkPart::Rotation) text=L"Drag to rotate | Hold Shift for 15-degree steps";
else if(part==MarkPart::Thickness) text=L"Drag to change thickness | Mouse wheel over object = size";
else if(part==MarkPart::Radius) text=L"Drag to resize the number | Mouse wheel = diameter";
else if(part>=MarkPart::Vertex0 && part<=MarkPart::Vertex2) text=L"Drag triangle vertex | Other vertices stay fixed";
else if(part==MarkPart::Start || part==MarkPart::End) text=L"Drag handle to resize | Endpoints can snap to objects and other arrows";
else if(c.selected>=0) {
const auto &m=c.marks[c.selected];
@@ -257,9 +267,11 @@ void updateStatus(Capture &c)
else if(c.pointer) text=L"Pointer (V): select and edit objects | Drag handles = geometry or thickness | Empty space clears selection";
else if(c.textTool) text=L"Text (T): click the image to type | Double-click existing text to edit";
else if(c.highlight) text=L"Highlight (H): drag to paint | Ctrl+drag = paint over an object | V = pointer";
else if(c.freehand) text=L"Freehand (F): Shift = 45-degree steps; move >50 px off line to turn | Ctrl = draw over objects";
else if(c.freehand) text=L"Freehand (F): auto-smooth / shapes; Ctrl+Z restores original | Shift = 45-degree steps | Ctrl = draw over objects";
else if(c.arrow) text=L"Drag to draw | Ctrl+drag over objects = linked connector | V = pointer";
else text=L"Number (N): click to add | V = select and edit | Ctrl+C = copy screenshot";
text=L"Zoom: "+std::to_wstring(int(std::lround(100.0*(c.view.right-c.view.left)/c.image->width)))+
L"% (Ctrl +/- / wheel; Ctrl+0: fit; middle drag: pan) | "+text;
if(text!=c.statusText) {
c.statusText=std::move(text);
SendMessageW(status,SB_SETTEXTW,0,(LPARAM)c.statusText.c_str());
@@ -299,6 +311,12 @@ void positionInlineText(Capture &c)
int width=std::min(std::max(120,MulDiv(bounds.right-bounds.left,viewWidth,c.image->width)+24),std::max(32,int(client.right)-x));
int height=std::min(std::max(40,MulDiv(bounds.bottom-bounds.top,viewWidth,c.image->width)+24),std::max(32,int(client.bottom)-c.statusHeight-y));
SetWindowPos(c.inlineText,nullptr,x-2,y-2,width,height,SWP_NOZORDER|SWP_NOACTIVATE);
RECT editorBounds{x-2,y-2,x-2+width,y-2+height},visible{};
IntersectRect(&visible,&editorBounds,&c.canvas);
auto clip=IsRectEmpty(&visible)?CreateRectRgn(0,0,0,0):
CreateRectRgn(visible.left-editorBounds.left,visible.top-editorBounds.top,
visible.right-editorBounds.left,visible.bottom-editorBounds.top);
if(!SetWindowRgn(c.inlineText,clip,TRUE)) DeleteObject(clip);
}
Mark textStyleDefaults(const Mark &source)
{
@@ -339,6 +357,10 @@ void finishInlineText(HWND w,Capture &c,bool commit)
}
LRESULT CALLBACK inlineTextProc(HWND w,UINT msg,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
{
if(msg==WM_KEYDOWN && (GetKeyState(VK_CONTROL)&0x8000) &&
(wp==VK_OEM_PLUS || wp==VK_ADD || wp==VK_OEM_MINUS || wp==VK_SUBTRACT || wp=='0' || wp==VK_NUMPAD0)) {
SendMessageW(GetParent(w),msg,wp,lp); return 0;
}
if(msg==WM_KEYDOWN && wp=='S' && (GetKeyState(VK_CONTROL)&0x8000)) {
PostMessageW(GetParent(w),WM_COMMAND,(GetKeyState(VK_SHIFT)&0x8000)?29:28,0); return 0;
}
@@ -372,9 +394,47 @@ void beginMarkText(HWND w,Capture &c,int index)
beginInlineText(w,c,label,index); c.editingLabel=true;
}
}
POINT rotateShapePoint(const Mark &m,POINT p,double direction=1)
{
if(m.shape==ScreenshotShape::None || m.rotation==0) return p;
double cx=(m.from.x+m.to.x)/2.0,cy=(m.from.y+m.to.y)/2.0;
double a=direction*m.rotation*3.141592653589793/180,cs=std::cos(a),sn=std::sin(a);
return {LONG(std::lround(cx+(p.x-cx)*cs-(p.y-cy)*sn)),
LONG(std::lround(cy+(p.x-cx)*sn+(p.y-cy)*cs))};
}
std::vector<POINT> shapeOutline(const Mark &m)
{
auto points=m.points;
if(points.empty()) {
auto r=region(m.from,m.to);
if(m.shape==ScreenshotShape::Rectangle)
points={{r.left,r.top},{r.right,r.top},{r.right,r.bottom},{r.left,r.bottom},{r.left,r.top}};
else if(m.shape==ScreenshotShape::Triangle)
points={{(r.left+r.right)/2,r.top},{r.right,r.bottom},{r.left,r.bottom},{(r.left+r.right)/2,r.top}};
else if(m.shape==ScreenshotShape::Trapezoid)
points={{r.left+(r.right-r.left)/4,r.top},{r.right-(r.right-r.left)/4,r.top},
{r.right,r.bottom},{r.left,r.bottom},{r.left+(r.right-r.left)/4,r.top}};
else {
for(int i=0;i<180;++i) {
double a=i*2*3.141592653589793/180;
points.push_back({LONG(std::lround((r.left+r.right)/2.0+(r.right-r.left)/2.0*std::cos(a))),
LONG(std::lround((r.top+r.bottom)/2.0+(r.bottom-r.top)/2.0*std::sin(a)))});
}
points.push_back(points.front());
}
}
for(auto &p:points) p=rotateShapePoint(m,p);
return points;
}
RECT markBounds(const Mark &m)
{
if(m.isText()) return screenshotTextBounds(m);
if(m.shape!=ScreenshotShape::None && m.rotation!=0) {
auto points=shapeOutline(m); RECT r{points[0].x,points[0].y,points[0].x,points[0].y};
for(auto p:points) { r.left=std::min(r.left,p.x); r.right=std::max(r.right,p.x);
r.top=std::min(r.top,p.y); r.bottom=std::max(r.bottom,p.y); }
return r;
}
RECT r=region(m.from,m.to);
for(auto p:m.points) {
r.left=std::min(r.left,p.x); r.top=std::min(r.top,p.y);
@@ -386,7 +446,7 @@ std::pair<POINT,POINT> thicknessSegment(const Mark &m)
{
if(m.shape!=ScreenshotShape::None) {
auto r=region(m.from,m.to);
return {{r.right,r.top},{r.left,r.top}};
return {rotateShapePoint(m,{r.right,r.top}),rotateShapePoint(m,{r.left,r.top})};
}
if(m.freehand && m.points.size()>1) {
size_t index=(m.points.size()-1)/2;
@@ -490,7 +550,10 @@ void drawMarks(HDC dc, const std::vector<Mark> &marks, const Mark *preview = nul
if(m.shape!=ScreenshotShape::None) {
auto hollow=SelectObject(dc,GetStockObject(HOLLOW_BRUSH));
auto r=region(m.from,m.to);
if(m.shape==ScreenshotShape::Rectangle) Rectangle(dc,r.left,r.top,r.right+1,r.bottom+1);
if(!m.points.empty() || m.rotation!=0 || m.shape==ScreenshotShape::Triangle || m.shape==ScreenshotShape::Trapezoid) {
auto points=shapeOutline(m); Polyline(dc,points.data(),int(points.size()));
}
else if(m.shape==ScreenshotShape::Rectangle) Rectangle(dc,r.left,r.top,r.right+1,r.bottom+1);
else Ellipse(dc,r.left,r.top,r.right+1,r.bottom+1);
SelectObject(dc,hollow);
SelectObject(dc,previousPen); DeleteObject(arrowPen);
@@ -605,7 +668,7 @@ void layout(HWND w, Capture &c)
RECT statusRect{}; GetWindowRect(status,&statusRect);
c.statusHeight=statusRect.bottom-statusRect.top;
r.bottom-=c.statusHeight;
const int positions[]{8,44,80,116,152,188,224,260,296,332,368,416,452,500};
const int positions[]{8,44,80,116,152,188,224,260,296,332,368,404,440,488,524,572};
static_assert(std::size(positions)==std::size(ToolIds));
for (size_t i = 0; i < std::size(ToolIds); ++i)
{
@@ -614,7 +677,7 @@ void layout(HWND w, Capture &c)
MulDiv(32,dpi,96),MulDiv(32,dpi,96),TRUE);
}
SendDlgItemMessageW(w,28,WM_SETFONT,(WPARAM)c.font,TRUE);
MoveWindow(GetDlgItem(w,28),MulDiv(540,dpi,96),MulDiv(6,dpi,96),
MoveWindow(GetDlgItem(w,28),MulDiv(612,dpi,96),MulDiv(6,dpi,96),
MulDiv(78,dpi,96),MulDiv(32,dpi,96),TRUE);
c.panelHeight=c.unit+MulDiv(40,dpi,96);
for(int id:{30,31,32,33,34,35}) SendDlgItemMessageW(w,id,WM_SETFONT,(WPARAM)c.font,TRUE);
@@ -625,13 +688,35 @@ void layout(HWND w, Capture &c)
MoveWindow(GetDlgItem(w,34),MulDiv(480,dpi,96),c.unit+MulDiv(2,dpi,96),MulDiv(28,dpi,96),MulDiv(28,dpi,96),TRUE);
MoveWindow(GetDlgItem(w,35),MulDiv(516,dpi,96),c.unit+MulDiv(2,dpi,96),MulDiv(28,dpi,96),MulDiv(28,dpi,96),TRUE);
syncLineOptions(w,c);
double ratio = std::min({1.0, double(std::max(1L,r.right-16))/c.image->width,
c.canvas={0,c.panelHeight,r.right,std::max(LONG(c.panelHeight+1),r.bottom)};
double ratio = c.zoom*std::min({1.0, double(std::max(1L,r.right-16))/c.image->width,
double(std::max(1L,r.bottom-c.panelHeight-16))/c.image->height});
int width = int(c.image->width*ratio), height = int(c.image->height*ratio);
c.view = {(r.right-width)/2, c.panelHeight+(r.bottom-c.panelHeight-height)/2,
(r.right+width)/2, c.panelHeight+(r.bottom-c.panelHeight+height)/2};
int width = std::max(1,int(std::lround(c.image->width*ratio))), height = std::max(1,int(std::lround(c.image->height*ratio)));
double maxX=std::max(0.0,(width-double(c.canvas.right-c.canvas.left))/2);
double maxY=std::max(0.0,(height-double(c.canvas.bottom-c.canvas.top))/2);
c.panX=std::clamp(c.panX,-maxX,maxX); c.panY=std::clamp(c.panY,-maxY,maxY);
LONG x=LONG(std::lround((r.right-width)/2.0+c.panX));
LONG y=LONG(std::lround(c.panelHeight+(r.bottom-c.panelHeight-height)/2.0+c.panY));
c.view = {x,y,x+width,y+height};
InvalidateRect(w, nullptr, FALSE);
}
void zoomCanvas(HWND w,Capture &c,double factor,POINT anchor,bool reset=false)
{
if(!c.editing || c.dragging || c.panning) return;
double u=double(anchor.x-c.view.left)/std::max(1L,c.view.right-c.view.left);
double v=double(anchor.y-c.view.top)/std::max(1L,c.view.bottom-c.view.top);
double next=reset?1.0:std::clamp(c.zoom*factor,.1,16.0);
if(next==c.zoom && !reset) return;
c.zoom=next;
if(reset) c.panX=c.panY=0;
layout(w,c);
if(!reset) {
c.panX+=anchor.x-(c.view.left+u*(c.view.right-c.view.left));
c.panY+=anchor.y-(c.view.top+v*(c.view.bottom-c.view.top));
layout(w,c);
}
positionInlineText(c); updateStatus(c); InvalidateRect(w,nullptr,FALSE);
}
POINT imagePoint(Capture &c, POINT p, bool clamp = true)
{
POINT result{MulDiv(p.x-c.view.left,c.image->width,std::max(1L,c.view.right-c.view.left)),
@@ -659,6 +744,10 @@ std::pair<int,MarkPart> markAt(Capture &c, POINT p)
if(c.selected>=0)
{
const auto &m=c.marks[c.selected];
if(m.shape!=ScreenshotShape::None) {
auto grip=screenshotShapeRotationHandle(m,double(c.unit)*c.image->width/std::max(1L,c.view.right-c.view.left));
if(std::hypot(double(p.x-grip.x),double(p.y-grip.y))<=tolerance) return {c.selected,MarkPart::Rotation};
}
if(m.isText() || (m.isLine() && !m.label.empty())) {
auto text=m.isText()?m:screenshotArrowLabel(m);
auto grip=screenshotTextRotationHandle(text,double(c.unit*0.6)*c.image->width/std::max(1L,c.view.right-c.view.left));
@@ -682,7 +771,7 @@ HCURSOR toolCursor(const Capture &c)
if(c.pointer) return LoadCursorW(nullptr,IDC_ARROW);
if(c.textTool) return LoadCursorW(nullptr,IDC_IBEAM);
if(c.freehand && c.pencilCursor) return c.pencilCursor;
int tool=c.highlight?19:c.straight?22:c.shape!=ScreenshotShape::None?22+int(c.shape):c.arrow?11:10;
int tool=c.highlight?19:c.straight?22:c.shape==ScreenshotShape::Trapezoid?37:c.shape==ScreenshotShape::Triangle?36:c.shape!=ScreenshotShape::None?22+int(c.shape):c.arrow?11:10;
for(size_t i=0;i<std::size(CursorTools);++i)
if(CursorTools[i]==tool && c.drawingCursors[i]) return c.drawingCursors[i];
return LoadCursorW(nullptr,IDC_CROSS);
@@ -693,6 +782,7 @@ HCURSOR actionCursor(const Capture &c,std::pair<int,MarkPart> hit,bool inside)
LPCWSTR cursor=nullptr;
if(hit.second==MarkPart::Body || hit.second==MarkPart::Label) cursor=IDC_SIZEALL;
else if(hit.second==MarkPart::Rotation) cursor=IDC_HAND;
else if(hit.second>=MarkPart::Vertex0 && hit.second<=MarkPart::Vertex2) cursor=IDC_SIZEALL;
else if(hit.second==MarkPart::Radius) cursor=IDC_SIZEWE;
else if(hit.second==MarkPart::Start || hit.second==MarkPart::End || hit.second==MarkPart::Thickness) {
const auto &mark=c.marks[hit.first];
@@ -708,7 +798,7 @@ HCURSOR actionCursor(const Capture &c,std::pair<int,MarkPart> hit,bool inside)
void captureCursor(HWND w, Capture &c)
{
POINT p; GetCursorPos(&p); ScreenToClient(w,&p);
bool inside=PtInRect(&c.view,p)!=FALSE;
bool inside=PtInRect(&c.view,p) && PtInRect(&c.canvas,p);
auto hit=c.editing?(c.dragging?std::pair{c.selected,c.part}:markAt(c,imagePoint(c,p,false))):std::pair{-1,MarkPart::None};
if(!c.dragging && !inside && hit.second!=MarkPart::Thickness && hit.second!=MarkPart::Rotation) hit={-1,MarkPart::None};
SetCursor(actionCursor(c,hit,inside || c.dragging));
@@ -764,7 +854,18 @@ void drawHandles(HDC dc, const Capture &c)
handle({m.from.x+m.radius,m.from.y});
}
else {
handle(m.from); handle(m.to);
if(m.shape==ScreenshotShape::Triangle) {
auto vertices=shapeOutline(m);
for(size_t i=0;i<3;++i) handle(vertices[i]);
} else { handle(rotateShapePoint(m,m.from)); handle(rotateShapePoint(m,m.to)); }
if(m.shape!=ScreenshotShape::None) {
auto r=region(m.from,m.to);
auto top=point(rotateShapePoint(m,{(r.left+r.right)/2,r.top}));
auto grip=screenshotShapeRotationHandle(m,double(c.unit)*c.image->width/std::max(1L,c.view.right-c.view.left));
auto end=point(grip); MoveToEx(dc,top.x,top.y,nullptr); LineTo(dc,end.x,end.y);
int radius=std::max(4,c.unit/8);
Ellipse(dc,end.x-radius,end.y-radius,end.x+radius+1,end.y+radius+1);
}
auto [from,to]=thicknessSegment(m);
auto mid=point({(from.x+to.x)/2,(from.y+to.y)/2});
auto grip=thicknessHandle(c,m),end=point(grip);
@@ -780,7 +881,8 @@ void drawTool(const DRAWITEMSTRUCT &item, const Capture &c)
RECT r=item.rcItem;
bool active=(item.CtlID==27 && c.pointer)||(item.CtlID==10 && !c.pointer && !c.arrow && !c.highlight && !c.freehand && !c.textTool)||(item.CtlID==11 && c.arrow && !c.straight && c.shape==ScreenshotShape::None)||
(item.CtlID==19 && c.highlight)||(item.CtlID==21 && c.freehand)||
(item.CtlID==22 && c.straight)||(item.CtlID>=23 && item.CtlID<=25 && int(c.shape)==int(item.CtlID)-22)||(item.CtlID==26 && c.textTool);
(item.CtlID==22 && c.straight)||(item.CtlID>=23 && item.CtlID<=25 && int(c.shape)==int(item.CtlID)-22)||(item.CtlID==26 && c.textTool)||
(item.CtlID==36 && c.shape==ScreenshotShape::Triangle)||(item.CtlID==37 && c.shape==ScreenshotShape::Trapezoid);
bool disabled=item.itemState&ODS_DISABLED;
POINT mouse; GetCursorPos(&mouse); ScreenToClient(item.hwndItem,&mouse);
bool hover=PtInRect(&r,mouse) && !disabled;
@@ -794,7 +896,16 @@ void drawTool(const DRAWITEMSTRUCT &item, const Capture &c)
RoundRect(dc,r.left,r.top,r.right,r.bottom,corner,corner);
SelectObject(dc,oldPen); SelectObject(dc,oldBrush); DeleteObject(pen); DeleteObject(brush);
int iconIndex=item.CtlID==35?13:item.CtlID==34?14:item.CtlID>=22?int(item.CtlID)-13:item.CtlID==18?5:item.CtlID==19?6:item.CtlID==20?7:item.CtlID==21?8:item.CtlID-10;
auto icon=item.CtlID==27?(HICON)LoadCursorW(nullptr,IDC_ARROW):c.toolIcons[disabled?2:active?1:0][iconIndex];
auto icon=(item.CtlID==36 || item.CtlID==37)?nullptr:item.CtlID==27?(HICON)LoadCursorW(nullptr,IDC_ARROW):c.toolIcons[disabled?2:active?1:0][iconIndex];
if(item.CtlID==36 || item.CtlID==37) {
int cx=(r.left+r.right)/2,cy=(r.top+r.bottom)/2,s=c.iconSize/2;
auto trianglePen=CreatePen(PS_SOLID,std::max(1,MulDiv(2,GetDpiForWindow(item.hwndItem),96)),
disabled?RGB(148,163,184):active?RGB(37,99,235):RGB(51,65,85));
auto previous=SelectObject(dc,trianglePen);
if(item.CtlID==36) { POINT vertices[]{{cx,cy-s},{cx+s,cy+s},{cx-s,cy+s},{cx,cy-s}}; Polyline(dc,vertices,4); }
else { POINT vertices[]{{cx-s/2,cy-s},{cx+s/2,cy-s},{cx+s,cy+s},{cx-s,cy+s},{cx-s/2,cy-s}}; Polyline(dc,vertices,5); }
SelectObject(dc,previous); DeleteObject(trianglePen);
}
if(icon) DrawIconEx(dc,(r.right-c.iconSize)/2,(r.bottom-c.iconSize)/2,icon,c.iconSize,c.iconSize,0,nullptr,DI_NORMAL);
if(item.CtlID==20) {
auto color=c.selected>=0?c.marks[c.selected].color:c.currentColor;
@@ -913,7 +1024,7 @@ void edit(HWND w, Capture &c)
InitCommonControlsEx(&statusControls);
CreateWindowExW(0,STATUSCLASSNAMEW,L"",WS_CHILD|WS_VISIBLE|SBARS_TOOLTIPS,
0,0,0,0,w,(HMENU)50,c.app.instance,nullptr);
const wchar_t *labels[]{L"Pointer (V): select and edit objects", L"Number (N)", L"Arrow (A); Ctrl+drag between objects to link", L"Straight line (L); Ctrl+drag between objects to link", L"Rectangle (R)", L"Circle (O)", L"Ellipse (E)", L"Freehand line (F); Shift for 45-degree steps; move >50 px off line to turn; Ctrl to draw over objects", L"Highlight (H); Ctrl+drag to paint over an object",
const wchar_t *labels[]{L"Pointer (V): select and edit objects", L"Number (N)", L"Arrow (A); Ctrl+drag between objects to link", L"Straight line (L); Ctrl+drag between objects to link", L"Rectangle (R)", L"Circle (O)", L"Ellipse (E)", L"Triangle (G): drag to draw; drag each vertex to reshape", L"Trapezoid (B): drag to draw", L"Freehand line (F); Shift for 45-degree steps; move >50 px off line to turn; Ctrl to draw over objects", L"Highlight (H); Ctrl+drag to paint over an object",
L"Text (T); double-click or F2 to edit", L"Color — selected object and new objects", L"Undo (Ctrl+Z)", L"Redo (Ctrl+Y / Ctrl+Shift+Z)", L"Copy (Ctrl+C)"};
static_assert(std::size(labels)==std::size(ToolIds));
auto saveButton=CreateWindowW(L"BUTTON",L"Save...",WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_PUSHBUTTON,
@@ -1008,7 +1119,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
}
break;
case WM_DRAWITEM:
if((wp>=10 && wp<=13) || (wp>=18 && wp<=27) || wp==34 || wp==35) { drawTool(*reinterpret_cast<DRAWITEMSTRUCT *>(lp),*c); return TRUE; }
if((wp>=10 && wp<=13) || (wp>=18 && wp<=27) || wp==34 || wp==35 || wp==36 || wp==37) { drawTool(*reinterpret_cast<DRAWITEMSTRUCT *>(lp),*c); return TRUE; }
break;
case WM_CTLCOLORSTATIC:
SetBkColor((HDC)wp,RGB(255,255,255)); SetTextColor((HDC)wp,RGB(51,65,85));
@@ -1102,13 +1213,13 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
if(changed) { c->copied=false; c->selected=-1; c->selectedLabel=false; c->wheelDelta=0; c->wheelTarget=-1; }
c->syncHistory();
}
if (LOWORD(wp)==10 || LOWORD(wp)==11 || LOWORD(wp)==19 || (LOWORD(wp)>=21 && LOWORD(wp)<=27))
if (LOWORD(wp)==10 || LOWORD(wp)==11 || LOWORD(wp)==19 || LOWORD(wp)==36 || LOWORD(wp)==37 || (LOWORD(wp)>=21 && LOWORD(wp)<=27))
{
c->pointer=LOWORD(wp)==27;
c->arrow = LOWORD(wp)==11 || (LOWORD(wp)>=22 && LOWORD(wp)<=25);
c->arrow = LOWORD(wp)==11 || LOWORD(wp)==36 || LOWORD(wp)==37 || (LOWORD(wp)>=22 && LOWORD(wp)<=25);
c->straight=LOWORD(wp)==22;
c->textTool=LOWORD(wp)==26;
c->shape=LOWORD(wp)>=23 && LOWORD(wp)<=25?ScreenshotShape(LOWORD(wp)-22):ScreenshotShape::None;
c->shape=LOWORD(wp)==37?ScreenshotShape::Trapezoid:LOWORD(wp)==36?ScreenshotShape::Triangle:LOWORD(wp)>=23 && LOWORD(wp)<=25?ScreenshotShape(LOWORD(wp)-22):ScreenshotShape::None;
c->selected=-1; c->selectedLabel=false;
c->highlight=LOWORD(wp)==19;
c->freehand=LOWORD(wp)==21;
@@ -1119,12 +1230,15 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
InvalidateRect(GetDlgItem(w,19),nullptr,FALSE);
InvalidateRect(GetDlgItem(w,21),nullptr,FALSE);
for(int id=22;id<=27;++id) InvalidateRect(GetDlgItem(w,id),nullptr,FALSE);
InvalidateRect(GetDlgItem(w,36),nullptr,FALSE);
InvalidateRect(GetDlgItem(w,37),nullptr,FALSE);
}
SetFocus(w); captureCursor(w,*c); InvalidateRect(w,nullptr,FALSE); return 0;
case WM_KEYDOWN:
if(wp==VK_SHIFT && c->editing && c->dragging && c->freehand && c->part==MarkPart::None && !c->strokeConstrained) {
c->strokeConstrained=true;
c->strokeUsedConstraint=true;
c->strokeAnchor=c->stroke.points.size()-1;
c->strokeAxis=0;
c->strokeAxisSettled=false;
@@ -1136,6 +1250,12 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
}
if (c->editing && !c->dragging)
{
if((GetKeyState(VK_CONTROL)&0x8000) &&
(wp==VK_OEM_PLUS || wp==VK_ADD || wp==VK_OEM_MINUS || wp==VK_SUBTRACT || wp=='0' || wp==VK_NUMPAD0)) {
POINT center{(c->canvas.left+c->canvas.right)/2,(c->canvas.top+c->canvas.bottom)/2};
zoomCanvas(w,*c,wp==VK_OEM_MINUS || wp==VK_SUBTRACT?1/1.25:1.25,center,wp=='0' || wp==VK_NUMPAD0);
return 0;
}
if(wp>=VK_LEFT && wp<=VK_DOWN && c->selected>=0 && !c->inlineText) {
POINT delta{wp==VK_LEFT?-1L:wp==VK_RIGHT?1L:0L,wp==VK_UP?-1L:wp==VK_DOWN?1L:0L};
const auto &original=c->marks[c->selected];
@@ -1170,6 +1290,8 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
if(wp=='R') SendMessageW(w,WM_COMMAND,23,0);
if(wp=='O') SendMessageW(w,WM_COMMAND,24,0);
if(wp=='E') SendMessageW(w,WM_COMMAND,25,0);
if(wp=='G') SendMessageW(w,WM_COMMAND,36,0);
if(wp=='B') SendMessageW(w,WM_COMMAND,37,0);
}
if (wp=='N' || wp=='A') SendMessageW(w,WM_COMMAND,wp=='N'?10:11,0);
if(wp=='H') SendMessageW(w,WM_COMMAND,19,0);
@@ -1194,7 +1316,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
case WM_LBUTTONDBLCLK:
if(c->editing && !c->dragging) {
POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
if(PtInRect(&c->view,p)) {
if(PtInRect(&c->view,p) && PtInRect(&c->canvas,p)) {
auto [index,part]=markAt(*c,imagePoint(*c,p));
if(index>=0 && (c->marks[index].isText() || c->marks[index].isLine())) {
c->selected=index; beginMarkText(w,*c,index);
@@ -1204,8 +1326,10 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
return 0;
case WM_LBUTTONDOWN:
{
if(c->panning) return 0;
finishInlineText(w,*c,true);
POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
if(c->editing && !PtInRect(&c->canvas,p)) return 0;
auto hitPart=c->editing?markAt(*c,imagePoint(*c,p,false)).second:MarkPart::None;
bool thickness=hitPart==MarkPart::Thickness || hitPart==MarkPart::Rotation;
if (c->editing && !PtInRect(&c->view,p) && !thickness)
@@ -1248,6 +1372,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
c->stroke.freehand=c->freehand; c->stroke.style=c->lineStyle; c->stroke.ends=c->freehandEnds;
c->stroke.points.push_back(p);
c->strokeConstrained=false;
c->strokeUsedConstraint=(wp&MK_SHIFT)!=0;
}
c->dragging=true; SetCapture(w);
}
@@ -1255,8 +1380,17 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
}
case WM_MOUSEWHEEL:
{
if(!c->editing || c->dragging) return 0;
if(!c->editing || c->dragging || c->panning) return 0;
POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)}; ScreenToClient(w,&p);
if(!PtInRect(&c->canvas,p)) return 0;
if(GET_KEYSTATE_WPARAM(wp)&MK_CONTROL) {
c->wheelDelta=0; c->wheelTarget=-1;
c->zoomWheelDelta+=GET_WHEEL_DELTA_WPARAM(wp);
int steps=c->zoomWheelDelta/WHEEL_DELTA; c->zoomWheelDelta%=WHEEL_DELTA;
if(steps) zoomCanvas(w,*c,std::pow(1.25,steps),p);
return 0;
}
c->zoomWheelDelta=0;
if(!PtInRect(&c->view,p)) return 0;
auto [index,part]=markAt(*c,imagePoint(*c,p));
if(index<0) { c->wheelDelta=0; c->wheelTarget=-1; return 0; }
@@ -1276,8 +1410,27 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
}
return 0;
}
case WM_MBUTTONDOWN:
{
POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
if(c->editing && !c->dragging && PtInRect(&c->canvas,p)) {
c->panning=true; c->panOrigin=p; SetCapture(w); SetCursor(LoadCursorW(nullptr,IDC_SIZEALL));
}
return 0;
}
case WM_MBUTTONUP:
if(c->panning) { c->panning=false; ReleaseCapture(); captureCursor(w,*c); }
return 0;
case WM_MOUSEMOVE:
case WM_LBUTTONUP:
if(c->panning) {
if(msg==WM_MOUSEMOVE) {
POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
c->panX+=p.x-c->panOrigin.x; c->panY+=p.y-c->panOrigin.y; c->panOrigin=p;
layout(w,*c); positionInlineText(*c); SetCursor(LoadCursorW(nullptr,IDC_SIZEALL));
}
return 0;
}
if (c->dragging)
{
POINT p{GET_X_LPARAM(lp),GET_Y_LPARAM(lp)};
@@ -1286,6 +1439,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
c->end=constrainScreenshotShape(c->shape,c->start,c->end,c->image->width,c->image->height);
if(c->editing && (c->highlight || c->freehand) && c->part==MarkPart::None) {
bool constrained=c->freehand && ((wp&MK_SHIFT) || (GetKeyState(VK_SHIFT)&0x8000));
c->strokeUsedConstraint=c->strokeUsedConstraint || constrained;
if(constrained) {
if(!c->strokeConstrained) {
c->strokeAnchor=c->stroke.points.size()-1;
@@ -1379,6 +1533,23 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
linkScreenshotEndpoint(mark,false,c->end,c->marks,6);
resolveScreenshotLinks(c->marks);
}
if(c->freehand && !c->strokeUsedConstraint &&
!c->marks.back().fromNumber && !c->marks.back().toNumber &&
!c->marks.back().fromLink.target && !c->marks.back().toLink.target) {
ScreenshotShape recognized{};
auto improved=improveScreenshotStroke(c->marks.back().points,&recognized);
if(!improved.empty()) {
c->remember(c->marks);
auto &mark=c->marks.back();
mark.points=std::move(improved);
mark.from=mark.points.front(); mark.to=mark.points.back();
if(recognized!=ScreenshotShape::None) {
mark.shape=recognized; mark.freehand=false; mark.ends=LineEnds::None;
auto bounds=markBounds(mark);
mark.from={bounds.left,bounds.top}; mark.to={bounds.right,bounds.bottom};
}
}
}
c->selected=int(c->marks.size())-1; c->selectedLabel=false;
}
else if (std::hypot(double(c->end.x-c->start.x),double(c->end.y-c->start.y))>=4)
@@ -1389,6 +1560,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
c->marks.back().style=c->lineStyle; c->marks.back().ends=c->straight || c->shape!=ScreenshotShape::None?LineEnds::None:c->arrowEnds;
c->marks.back().shape=c->shape;
auto &mark=c->marks.back();
if(mark.shape==ScreenshotShape::Triangle || mark.shape==ScreenshotShape::Trapezoid) mark.points=shapeOutline(mark);
linkScreenshotEndpoint(mark,true,c->start,c->marks,6);
linkScreenshotEndpoint(mark,false,c->end,c->marks,6);
resolveScreenshotLinks(c->marks);
@@ -1401,6 +1573,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
captureCursor(w,*c);
return 0;
case WM_CAPTURECHANGED:
c->panning=false;
if(c->dragging && c->part!=MarkPart::None)
{
c->marks=std::move(c->beforeDrag); c->part=MarkPart::None;
@@ -1410,7 +1583,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
if (c->editing)
{
auto limits = reinterpret_cast<MINMAXINFO *>(lp);
limits->ptMinTrackSize = {MulDiv(650,GetDpiForWindow(w),96),MulDiv(240,GetDpiForWindow(w),96)};
limits->ptMinTrackSize = {MulDiv(730,GetDpiForWindow(w),96),MulDiv(240,GetDpiForWindow(w),96)};
return 0;
}
break;
@@ -1460,7 +1633,7 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
auto previous=SelectObject(buffer,divider);
MoveToEx(buffer,0,c->panelHeight-1,nullptr); LineTo(buffer,client.right,c->panelHeight-1);
int dpi=GetDpiForWindow(w);
for(int x:{368,452}) {
for(int x:{440,524}) {
MoveToEx(buffer,MulDiv(x,dpi,96),MulDiv(13,dpi,96),nullptr);
LineTo(buffer,MulDiv(x,dpi,96),MulDiv(31,dpi,96));
}
@@ -1478,9 +1651,12 @@ LRESULT CALLBACK captureProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
}
drawMarks(rendered.dc,visibleMarks,c->dragging && c->part==MarkPart::None?((c->highlight || c->freehand)?&c->stroke:&preview):nullptr);
SetStretchBltMode(buffer,HALFTONE); SetBrushOrgEx(buffer,0,0,nullptr);
int savedCanvas=SaveDC(buffer);
IntersectClipRect(buffer,c->canvas.left,c->canvas.top,c->canvas.right,c->canvas.bottom);
StretchBlt(buffer,c->view.left,c->view.top,c->view.right-c->view.left,c->view.bottom-c->view.top,
rendered.dc,0,0,rendered.width,rendered.height,SRCCOPY);
drawHandles(buffer,*c);
RestoreDC(buffer,savedCanvas);
BitBlt(dc,0,0,width,height,buffer,0,0,SRCCOPY);
}
}
@@ -1525,6 +1701,11 @@ POINT screenshotTextRotationHandle(const ScreenshotMark &m,double clearance)
auto r=plainTextBounds(m);
return rotateTextPoint(m,{(r.left+r.right)/2,r.top-LONG(std::lround(clearance))});
}
POINT screenshotShapeRotationHandle(const ScreenshotMark &m,double clearance)
{
auto r=region(m.from,m.to);
return rotateShapePoint(m,{(r.left+r.right)/2,r.top-LONG(std::lround(clearance))});
}
ScreenshotMark screenshotArrowLabel(const ScreenshotMark &m)
{
ScreenshotMark label{{0,0},{0,0},0};
@@ -1604,23 +1785,23 @@ void assignMarkIds(std::vector<ScreenshotMark> &marks)
}
POINT objectAnchor(const ScreenshotMark &m,const ScreenshotLink &link)
{
if(m.isText() || m.shape!=ScreenshotShape::None) {
if(m.isText() || (m.shape!=ScreenshotShape::None && m.points.empty())) {
auto r=m.isText()?plainTextBounds(m):region(m.from,m.to);
POINT p{LONG(std::lround(r.left+(r.right-r.left)*link.u)),LONG(std::lround(r.top+(r.bottom-r.top)*link.v))};
return m.isText()?rotateTextPoint(m,p):p;
return m.isText()?rotateTextPoint(m,p):rotateShapePoint(m,p);
}
size_t segments=m.points.size()>1?m.points.size()-1:1;
double along=std::clamp(link.u,0.0,1.0)*segments;
size_t i=std::min(size_t(along),segments-1); double t=along-i;
POINT a=m.points.size()>1?m.points[i]:m.from,b=m.points.size()>1?m.points[i+1]:m.to;
return {LONG(std::lround(a.x+(b.x-a.x)*t)),LONG(std::lround(a.y+(b.y-a.y)*t))};
return rotateShapePoint(m,{LONG(std::lround(a.x+(b.x-a.x)*t)),LONG(std::lround(a.y+(b.y-a.y)*t))});
}
bool findObjectAnchor(const ScreenshotMark &m,POINT drop,double tolerance,ScreenshotLink &link)
{
link={m.id,0,0};
if(m.isText() || m.shape!=ScreenshotShape::None) {
if(m.isText() || (m.shape!=ScreenshotShape::None && m.points.empty())) {
auto r=m.isText()?plainTextBounds(m):region(m.from,m.to);
POINT p=m.isText()?rotateTextPoint(m,drop,-1):drop;
POINT p=m.isText()?rotateTextPoint(m,drop,-1):rotateShapePoint(m,drop,-1);
double w=std::max(1L,r.right-r.left),h=std::max(1L,r.bottom-r.top);
double x=(p.x-r.left)/w,y=(p.y-r.top)/h;
bool inside=x>=0 && x<=1 && y>=0 && y<=1;
@@ -1640,6 +1821,7 @@ bool findObjectAnchor(const ScreenshotMark &m,POINT drop,double tolerance,Screen
auto anchor=objectAnchor(m,link);
return inside || std::hypot(double(drop.x-anchor.x),double(drop.y-anchor.y))<=tolerance;
}
drop=rotateShapePoint(m,drop,-1);
double best=1e100;
size_t segments=m.points.size()>1?m.points.size()-1:1;
for(size_t i=0;i<segments;++i) {
@@ -1724,6 +1906,13 @@ void resolveScreenshotLinks(std::vector<ScreenshotMark> &marks)
}
MarkPart hitScreenshotMark(const ScreenshotMark &m, POINT p, double tolerance)
{
if(m.shape==ScreenshotShape::Triangle) {
auto vertices=shapeOutline(m);
for(int i=0;i<3;++i)
if(std::hypot(double(p.x-vertices[i].x),double(p.y-vertices[i].y))<=tolerance)
return MarkPart(int(MarkPart::Vertex0)+i);
}
p=rotateShapePoint(m,p,-1);
if(m.isText()) {
auto r=plainTextBounds(m);
auto local=rotateTextPoint(m,p,-1);
@@ -1734,8 +1923,10 @@ MarkPart hitScreenshotMark(const ScreenshotMark &m, POINT p, double tolerance)
auto distance=[](POINT a, POINT b) { return std::hypot(double(a.x-b.x),double(a.y-b.y)); };
if(!m.points.empty())
{
if(m.freehand && distance(p,m.from)<=tolerance) return MarkPart::Start;
if(m.freehand && distance(p,m.to)<=tolerance) return MarkPart::End;
if(m.shape!=ScreenshotShape::Triangle) {
if((m.freehand || m.shape!=ScreenshotShape::None) && distance(p,m.from)<=tolerance) return MarkPart::Start;
if((m.freehand || m.shape!=ScreenshotShape::None) && distance(p,m.to)<=tolerance) return MarkPart::End;
}
double reach=tolerance+std::clamp(m.thickness,m.isHighlight()?4:1,m.isHighlight()?100:30)/2.0;
POINT from=m.points.front();
for(auto to:m.points) {
@@ -1789,7 +1980,32 @@ ScreenshotMark dragScreenshotMark(const ScreenshotMark &original, MarkPart part,
{
auto m=original;
if(position.x==origin.x && position.y==origin.y) return m;
if(part==MarkPart::Rotation && (m.isText() || (m.isLine() && !m.label.empty()))) {
if(part>=MarkPart::Vertex0 && part<=MarkPart::Vertex2 && m.shape==ScreenshotShape::Triangle) {
if(m.points.empty()) { auto local=m; local.rotation=0; m.points=shapeOutline(local); }
size_t index=size_t(int(part)-int(MarkPart::Vertex0)),fixed=(index+1)%3;
auto fixedWorld=rotateShapePoint(m,m.points[fixed]);
auto vertexWorld=rotateShapePoint(m,m.points[index]);
POINT target{std::clamp(vertexWorld.x+position.x-origin.x,0L,LONG(width-1)),
std::clamp(vertexWorld.y+position.y-origin.y,0L,LONG(height-1))};
m.points[index]=rotateShapePoint(m,target,-1); m.points[3]=m.points[0];
RECT bounds{m.points[0].x,m.points[0].y,m.points[0].x,m.points[0].y};
for(size_t i=1;i<3;++i) {auto p=m.points[i]; bounds.left=std::min(bounds.left,p.x); bounds.right=std::max(bounds.right,p.x);
bounds.top=std::min(bounds.top,p.y); bounds.bottom=std::max(bounds.bottom,p.y);}
m.from={bounds.left,bounds.top}; m.to={bounds.right,bounds.bottom};
auto shifted=rotateShapePoint(m,m.points[fixed]);
LONG dx=fixedWorld.x-shifted.x,dy=fixedWorld.y-shifted.y;
m.from.x+=dx; m.to.x+=dx; m.from.y+=dy; m.to.y+=dy;
for(auto &p:m.points) {p.x+=dx;p.y+=dy;}
}
else if(part==MarkPart::Rotation && m.shape!=ScreenshotShape::None) {
double cx=(m.from.x+m.to.x)/2.0,cy=(m.from.y+m.to.y)/2.0;
if(std::hypot(position.x-cx,position.y-cy)<1) return m;
double a=std::atan2(origin.y-cy,origin.x-cx),b=std::atan2(position.y-cy,position.x-cx);
m.rotation+=(b-a)*180/3.141592653589793;
if(snapRotation) m.rotation=std::round(m.rotation/15)*15;
m.rotation=std::remainder(m.rotation,360);
}
else if(part==MarkPart::Rotation && (m.isText() || (m.isLine() && !m.label.empty()))) {
if(position.x==origin.x && position.y==origin.y) return m;
auto text=m.isText()?m:screenshotArrowLabel(m);
auto r=plainTextBounds(text);
@@ -1843,13 +2059,34 @@ ScreenshotMark dragScreenshotMark(const ScreenshotMark &original, MarkPart part,
}
else if(part==MarkPart::Start || part==MarkPart::End)
{
origin=rotateShapePoint(original,origin,-1);
position=rotateShapePoint(original,position,-1);
(part==MarkPart::Start?m.fromNumber:m.toNumber)=0;
(part==MarkPart::Start?m.fromLink:m.toLink)={};
auto &endpoint=part==MarkPart::Start?m.from:m.to;
endpoint.x=std::clamp(endpoint.x+position.x-origin.x,0L,LONG(width-1));
endpoint.y=std::clamp(endpoint.y+position.y-origin.y,0L,LONG(height-1));
endpoint=constrainScreenshotShape(m.shape,part==MarkPart::Start?m.to:m.from,endpoint,width,height);
if(m.shape!=ScreenshotShape::None && !m.points.empty()) {
if(m.from.x==m.to.x || m.from.y==m.to.y) return original;
// Resize the entire recognized outline, not just a pencil endpoint.
// Keep the opposite corner fixed, including when dragging across it.
double oldWidth=original.to.x-original.from.x,oldHeight=original.to.y-original.from.y;
for(auto &point:m.points) {
double u=oldWidth?(point.x-original.from.x)/oldWidth:0;
double v=oldHeight?(point.y-original.from.y)/oldHeight:0;
point={LONG(std::lround(m.from.x+u*(m.to.x-m.from.x))),
LONG(std::lround(m.from.y+v*(m.to.y-m.from.y)))};
}
}
if(m.freehand && !m.points.empty()) (part==MarkPart::Start?m.points.front():m.points.back())=endpoint;
if(m.shape!=ScreenshotShape::None && m.rotation!=0) {
auto fixedBefore=rotateShapePoint(original,part==MarkPart::Start?original.to:original.from);
auto fixedAfter=rotateShapePoint(m,part==MarkPart::Start?m.to:m.from);
LONG dx=fixedBefore.x-fixedAfter.x,dy=fixedBefore.y-fixedAfter.y;
m.from.x+=dx; m.to.x+=dx; m.from.y+=dy; m.to.y+=dy;
for(auto &p:m.points) {p.x+=dx;p.y+=dy;}
}
}
return m;
}
src/screenshot.h
+4 -3
View File
@@ -15,7 +15,7 @@ void showScreenshot(ScreenshotHost &);
void showScreenshotEditor(ScreenshotHost &,const Clip &);
enum class LineStyle { Solid, Dotted, Dashed, DashDot };
enum class LineEnds { End, Start, Both, None };
enum class ScreenshotShape { None, Rectangle, Circle, Ellipse };
enum class ScreenshotShape { None, Rectangle, Circle, Ellipse, Triangle, Trapezoid };
struct ScreenshotOffset { double x, y; };
struct ScreenshotLink {
unsigned long long target{};
@@ -40,7 +40,7 @@ struct ScreenshotMark {
unsigned long long id{};
ScreenshotLink fromLink, toLink;
bool isText() const { return !text.empty(); }
bool isHighlight() const { return !points.empty() && !freehand; }
bool isHighlight() const { return !points.empty() && !freehand && shape==ScreenshotShape::None; }
bool isLine() const { return !number && !isText() && !isHighlight() && shape==ScreenshotShape::None; }
};
class ScreenshotHistory {
@@ -55,7 +55,7 @@ class ScreenshotHistory {
void resolveScreenshotLinks(std::vector<ScreenshotMark> &);
void linkScreenshotEndpoint(ScreenshotMark &, bool start, POINT drop,
std::vector<ScreenshotMark> &, double tolerance);
enum class MarkPart { None, Body, Start, End, Radius, Thickness, Rotation, Label };
enum class MarkPart { None, Body, Start, End, Radius, Thickness, Rotation, Label, Vertex0, Vertex1, Vertex2 };
POINT screenshotThicknessHandle(const ScreenshotMark &, double clearance = 16);
ScreenshotMark cloneScreenshotMark(const ScreenshotMark &, const std::vector<ScreenshotMark> &, int width, int height);
int nextScreenshotNumber(const std::vector<ScreenshotMark> &);
@@ -65,6 +65,7 @@ ScreenshotMark dragScreenshotMark(const ScreenshotMark &, MarkPart, POINT origin
POINT constrainScreenshotShape(ScreenshotShape, POINT anchor, POINT position, int width, int height);
RECT screenshotTextBounds(const ScreenshotMark &);
POINT screenshotTextRotationHandle(const ScreenshotMark &, double clearance=24);
POINT screenshotShapeRotationHandle(const ScreenshotMark &, double clearance=32);
ScreenshotMark screenshotArrowLabel(const ScreenshotMark &);
// Render at source resolution; never reads or writes the system clipboard.
Clip screenshotClip(HDC source, int width, int height, const std::vector<ScreenshotMark> &marks);
src/stroke_improvement.h
+218
View File
@@ -0,0 +1,218 @@
#pragma once
#include "screenshot.h"
#include <algorithm>
#include <cmath>
#include <vector>
namespace ks::stroke_detail {
struct Point { double x, y; };
inline double distance(Point a, Point b) { return std::hypot(a.x-b.x,a.y-b.y); }
inline double length(const std::vector<Point> &p) {
double total=0;
for(size_t i=1;i<p.size();++i) total+=distance(p[i-1],p[i]);
return total;
}
// Arc-length sampling makes fitting independent of mouse speed and bounds its cost.
inline std::vector<Point> sample(const std::vector<Point> &p, size_t count) {
std::vector<Point> out{p.front()};
double step=length(p)/(count-1), traversed=0;
size_t segment=1;
for(size_t i=1;i+1<count;++i) {
double target=i*step;
while(segment+1<p.size() && traversed+distance(p[segment-1],p[segment])<target) {
traversed+=distance(p[segment-1],p[segment]); ++segment;
}
double span=distance(p[segment-1],p[segment]);
double t=span>0?(target-traversed)/span:0;
out.push_back({p[segment-1].x+t*(p[segment].x-p[segment-1].x),
p[segment-1].y+t*(p[segment].y-p[segment-1].y)});
}
out.push_back(p.back()); return out;
}
inline double segmentDistance(Point p, Point a, Point b) {
double dx=b.x-a.x,dy=b.y-a.y,den=dx*dx+dy*dy;
double t=den?std::clamp(((p.x-a.x)*dx+(p.y-a.y)*dy)/den,0.0,1.0):0;
return distance(p,{a.x+t*dx,a.y+t*dy});
}
inline double cross(Point a, Point b, Point c) { return (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x); }
}
namespace ks {
// Returns a replacement path; an empty result means no visible improvement.
// Report recognized geometry separately from a smoothed freehand path.
inline std::vector<POINT> improveScreenshotStroke(const std::vector<POINT> &input, ScreenshotShape *shape=nullptr) {
if(shape) *shape=ScreenshotShape::None;
using namespace stroke_detail;
if(input.size()<5) return {};
std::vector<Point> raw;
for(auto p:input) if(raw.empty() || distance(raw.back(),{double(p.x),double(p.y)})>0)
raw.push_back({double(p.x),double(p.y)});
double total=length(raw);
if(raw.size()<5 || total<16) return {};
auto points=sample(raw,128);
double left=points[0].x,right=left,top=points[0].y,bottom=top;
for(auto p:points) { left=std::min(left,p.x); right=std::max(right,p.x); top=std::min(top,p.y); bottom=std::max(bottom,p.y); }
double scale=std::min(right-left,bottom-top);
std::vector<Point> best;
double bestScore=1e30;
double gap=distance(raw.front(),raw.back());
if(scale>=20 && gap<=scale*.5) {
auto consider=[&](std::vector<Point> candidate, ScreenshotShape kind=ScreenshotShape::Rectangle) {
bool oval=kind==ScreenshotShape::Circle || kind==ScreenshotShape::Ellipse;
if(!oval && gap>scale*.22) return;
double perimeter=length(candidate);
if(total<perimeter*.82 || total>perimeter*1.25) return;
auto probes=sample(candidate,128);
double sum=0,maximum=0;
auto measure=[&](const std::vector<Point> &a,const std::vector<Point> &b) {
for(auto p:a) {
double d=1e30;
for(size_t i=1;i<b.size();++i) d=std::min(d,segmentDistance(p,b[i-1],b[i]));
sum+=d*d; maximum=std::max(maximum,d);
}
};
measure(points,candidate); measure(probes,points);
double score=std::sqrt(sum/256);
if(maximum<=std::max(3.0,scale*(oval?.22:.12)) && score<=std::max(1.5,scale*(oval?.085:.055)) && score<bestScore) {
bestScore=score; best=std::move(candidate);
if(shape) *shape=kind;
}
};
// Fit oriented bounding boxes; testing angles also handles tilted ovals.
for(int degrees=0;degrees<180;degrees+=5) {
double angle=degrees*3.141592653589793/180,cs=std::cos(angle),sn=std::sin(angle);
double x0=1e30,y0=x0,x1=-x0,y1=-x0;
for(auto p:points) {
double x=p.x*cs+p.y*sn,y=-p.x*sn+p.y*cs;
x0=std::min(x0,x); x1=std::max(x1,x); y0=std::min(y0,y); y1=std::max(y1,y);
}
auto world=[&](double x,double y)->Point { return {x*cs-y*sn,x*sn+y*cs}; };
consider({world(x0,y0),world(x1,y0),world(x1,y1),world(x0,y1),world(x0,y0)});
double rx=(x1-x0)/2,ry=(y1-y0)/2;
double cx=(x0+x1)/2,cy=(y0+y1)/2;
std::vector<Point> local;
for(auto p:points) local.push_back({p.x*cs+p.y*sn,-p.x*sn+p.y*cs});
// Fit four sides to their supporting samples. Extremal bounds exaggerate
// crooked corners and can unfairly make an oval score better than a box.
double sides[]{x0,x1,y0,y1};
bool supported=true;
for(int iteration=0;iteration<6;++iteration) {
double sums[4]{}; int counts[4]{};
for(auto p:local) {
double distances[]{std::abs(p.x-sides[0]),std::abs(p.x-sides[1]),
std::abs(p.y-sides[2]),std::abs(p.y-sides[3])};
auto side=std::min_element(distances,distances+4)-distances;
sums[side]+=side<2?p.x:p.y; ++counts[side];
}
for(int side=0;side<4;++side) {
if(counts[side]<10) { supported=false; break; }
sides[side]=sums[side]/counts[side];
}
if(!supported) break;
}
if(supported && sides[1]-sides[0]>=16 && sides[3]-sides[2]>=16)
consider({world(sides[0],sides[2]),world(sides[1],sides[2]),
world(sides[1],sides[3]),world(sides[0],sides[3]),world(sides[0],sides[2])});
// Fit the whole gesture instead of letting a single mouse wobble set the bounds.
auto error=[&](double x,double y,double a,double b) {
if(a<8 || b<8) return 1e30;
double sum=0;
for(auto p:local) {
double u=(p.x-x)/a,v=(p.y-y)/b,r=std::hypot(u,v);
double normal=std::hypot(u/a,v/b);
double d=normal>1e-9?(r-1)*r/normal:std::min(a,b);
sum+=d*d;
}
return sum;
};
double fit=error(cx,cy,rx,ry),step=std::max(rx,ry)*.08;
for(int iteration=0;iteration<10;++iteration) {
for(int parameter=0;parameter<4;++parameter) for(int sign:{-1,1}) {
double values[]{cx,cy,rx,ry}; values[parameter]+=sign*step;
double next=error(values[0],values[1],values[2],values[3]);
if(next<fit) { fit=next; cx=values[0]; cy=values[1]; rx=values[2]; ry=values[3]; }
}
step*=.65;
}
// Require almost one complete turn, with little retracing. This admits a small
// closing gap or overshoot but rejects C-shaped arcs, spirals and scribbles.
double turn=0,travel=0;
for(size_t i=1;i<local.size();++i) {
double a=std::atan2((local[i-1].y-cy)/ry,(local[i-1].x-cx)/rx);
double b=std::atan2((local[i].y-cy)/ry,(local[i].x-cx)/rx);
double delta=std::remainder(b-a,2*3.141592653589793);
turn+=delta; travel+=std::abs(delta);
}
if(std::abs(turn)<5.4 || std::abs(turn)>7.1 || travel-std::abs(turn)>.65) continue;
// Near-circular gestures become true circles.
bool circle=std::abs(rx-ry)<=std::max(rx,ry)*.12;
if(circle) rx=ry=(rx+ry)/2;
std::vector<Point> oval;
for(int i=0;i<96;++i) {
double t=i*2*3.141592653589793/96;
oval.push_back(world(cx+rx*std::cos(t),cy+ry*std::sin(t)));
}
oval.push_back(oval.front()); consider(std::move(oval),circle?ScreenshotShape::Circle:ScreenshotShape::Ellipse);
}
auto sorted=points;
std::sort(sorted.begin(),sorted.end(),[](Point a,Point b){return a.x<b.x || (a.x==b.x && a.y<b.y);});
std::vector<Point> hull;
for(auto p:sorted) {
while(hull.size()>1 && cross(hull[hull.size()-2],hull.back(),p)<=0) hull.pop_back();
hull.push_back(p);
}
size_t lower=hull.size();
for(size_t i=sorted.size()-1;i-->0;) {
auto p=sorted[i];
while(hull.size()>lower && cross(hull[hull.size()-2],hull.back(),p)<=0) hull.pop_back();
hull.push_back(p);
}
hull.pop_back();
while(hull.size()>3) {
if(hull.size()==4 && bestScore>scale*.035) {
// Opposite edges must already be nearly parallel; retain their unequal
// lengths and fit a shared direction instead of accepting any quadrilateral.
for(size_t i=0;i<2;++i) {
Point a=hull[i],b=hull[i+1],c=hull[(i+2)%4],d=hull[(i+3)%4];
double ab=distance(a,b),cd=distance(c,d);
if(std::min(ab,cd)<16 || std::min(ab,cd)/std::max(ab,cd)>.8) continue;
Point u{(b.x-a.x)/ab,(b.y-a.y)/ab},v{(c.x-d.x)/cd,(c.y-d.y)/cd};
if(u.x*v.x+u.y*v.y<.96) continue;
double norm=std::hypot(u.x+v.x,u.y+v.y);
Point axis{(u.x+v.x)/norm,(u.y+v.y)/norm};
auto along=[&](Point p){return p.x*axis.x+p.y*axis.y;};
auto across=[&](Point p){return -p.x*axis.y+p.y*axis.x;};
double y0=(across(a)+across(b))/2,y1=(across(c)+across(d))/2;
if(std::abs(y1-y0)<20) continue;
auto fit=[&](Point p,double y)->Point {double x=along(p);return {x*axis.x-y*axis.y,x*axis.y+y*axis.x};};
std::vector<Point> candidate{fit(a,y0),fit(b,y0),fit(c,y1),fit(d,y1),fit(a,y0)};
consider(std::move(candidate),ScreenshotShape::Trapezoid);
}
}
size_t remove=0; double area=1e30;
for(size_t i=0;i<hull.size();++i) {
double a=std::abs(cross(hull[(i+hull.size()-1)%hull.size()],hull[i],hull[(i+1)%hull.size()]));
if(a<area) { area=a; remove=i; }
}
hull.erase(hull.begin()+remove);
}
if(hull.size()==3) { hull.push_back(hull.front()); consider(hull,ScreenshotShape::Triangle); }
}
if(best.empty()) {
// A small spatial filter suppresses jitter without moving endpoints or flattening broad curves.
best=sample(raw,size_t(std::clamp(std::ceil(total/2)+1,5.0,2048.0)));
auto original=best;
for(size_t i=1;i+1<best.size();++i)
best[i]={(original[i-1].x+2*original[i].x+original[i+1].x)/4,
(original[i-1].y+2*original[i].y+original[i+1].y)/4};
}
std::vector<POINT> result;
for(auto p:best) {
POINT q{LONG(std::lround(p.x)),LONG(std::lround(p.y))};
if(result.empty() || result.back().x!=q.x || result.back().y!=q.y) result.push_back(q);
}
if(result.size()==input.size() && std::equal(result.begin(),result.end(),input.begin(),
[](POINT a,POINT b){return a.x==b.x && a.y==b.y;})) return {};
return result;
}
}
src/update.h
+1 -1
View File
@@ -2,7 +2,7 @@
#include "platform.h"
namespace ks
{
inline constexpr wchar_t AppVersion[] = L"0.6.23";
inline constexpr wchar_t AppVersion[] = L"0.6.24";
inline constexpr UINT UpdateMessage = WM_APP + 7;
inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000;
inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000;