mirror of
https://github.com/reactos/reactos.git
synced 2024-09-06 10:52:52 +00:00
![Katayama Hirofumi MZ](/assets/img/avatar_default.png)
- s/CANVAS_HITTEST/HITTEST/ - s/m_whereHit/m_hitCanvasSizeBox/ - s/m_rcNew/m_rcResizing/ - Add comments to CCanvasWindow. CORE-18867
531 lines
14 KiB
C++
531 lines
14 KiB
C++
/*
|
|
* PROJECT: PAINT for ReactOS
|
|
* LICENSE: LGPL-2.0-or-later (https://spdx.org/licenses/LGPL-2.0-or-later)
|
|
* PURPOSE: Keep track of selection parameters, notify listeners
|
|
* COPYRIGHT: Copyright 2009 Benedikt Freisen <b.freisen@gmx.net>
|
|
* Copyright 2019 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
|
|
SelectionModel selectionModel;
|
|
|
|
/* FUNCTIONS ********************************************************/
|
|
|
|
SelectionModel::SelectionModel()
|
|
: m_hbmColor(NULL)
|
|
, m_hbmMask(NULL)
|
|
, m_ptStack(NULL)
|
|
, m_iPtSP(0)
|
|
, m_rgbBack(RGB(255, 255, 255))
|
|
, m_bShow(FALSE)
|
|
, m_bContentChanged(FALSE)
|
|
{
|
|
::SetRectEmpty(&m_rc);
|
|
::SetRectEmpty(&m_rcOld);
|
|
m_ptHit.x = m_ptHit.y = -1;
|
|
}
|
|
|
|
SelectionModel::~SelectionModel()
|
|
{
|
|
ClearColor();
|
|
ClearMask();
|
|
ResetPtStack();
|
|
}
|
|
|
|
void SelectionModel::ResetPtStack()
|
|
{
|
|
if (m_ptStack)
|
|
{
|
|
free(m_ptStack);
|
|
m_ptStack = NULL;
|
|
}
|
|
m_iPtSP = 0;
|
|
}
|
|
|
|
void SelectionModel::PushToPtStack(POINT pt)
|
|
{
|
|
#define GROW_COUNT 256
|
|
if (m_iPtSP % GROW_COUNT == 0)
|
|
{
|
|
INT nNewCount = m_iPtSP + GROW_COUNT;
|
|
LPPOINT pptNew = (LPPOINT)realloc(m_ptStack, sizeof(POINT) * nNewCount);
|
|
if (pptNew == NULL)
|
|
return;
|
|
m_ptStack = pptNew;
|
|
}
|
|
m_ptStack[m_iPtSP] = pt;
|
|
m_iPtSP++;
|
|
#undef GROW_COUNT
|
|
}
|
|
|
|
void SelectionModel::ShiftPtStack(INT dx, INT dy)
|
|
{
|
|
for (INT i = 0; i < m_iPtSP; ++i)
|
|
{
|
|
POINT& pt = m_ptStack[i];
|
|
pt.x += dx;
|
|
pt.y += dy;
|
|
}
|
|
}
|
|
|
|
void SelectionModel::BuildMaskFromPtStack()
|
|
{
|
|
CRect rc = { MAXLONG, MAXLONG, 0, 0 };
|
|
for (INT i = 0; i < m_iPtSP; ++i)
|
|
{
|
|
POINT& pt = m_ptStack[i];
|
|
rc.left = min(pt.x, rc.left);
|
|
rc.top = min(pt.y, rc.top);
|
|
rc.right = max(pt.x, rc.right);
|
|
rc.bottom = max(pt.y, rc.bottom);
|
|
}
|
|
rc.right += 1;
|
|
rc.bottom += 1;
|
|
|
|
m_rc = m_rcOld = rc;
|
|
|
|
ClearMask();
|
|
|
|
ShiftPtStack(-m_rcOld.left, -m_rcOld.top);
|
|
|
|
HDC hdcMem = ::CreateCompatibleDC(NULL);
|
|
m_hbmMask = ::CreateBitmap(rc.Width(), rc.Height(), 1, 1, NULL);
|
|
HGDIOBJ hbmOld = ::SelectObject(hdcMem, m_hbmMask);
|
|
::FillRect(hdcMem, &rc, (HBRUSH)::GetStockObject(BLACK_BRUSH));
|
|
HGDIOBJ hPenOld = ::SelectObject(hdcMem, GetStockObject(NULL_PEN));
|
|
HGDIOBJ hbrOld = ::SelectObject(hdcMem, GetStockObject(WHITE_BRUSH));
|
|
::Polygon(hdcMem, m_ptStack, m_iPtSP);
|
|
::SelectObject(hdcMem, hbrOld);
|
|
::SelectObject(hdcMem, hPenOld);
|
|
::SelectObject(hdcMem, hbmOld);
|
|
::DeleteDC(hdcMem);
|
|
|
|
ShiftPtStack(+m_rcOld.left, +m_rcOld.top);
|
|
}
|
|
|
|
void SelectionModel::DrawBackgroundPoly(HDC hDCImage, COLORREF crBg)
|
|
{
|
|
if (::IsRectEmpty(&m_rcOld))
|
|
return;
|
|
|
|
HGDIOBJ hPenOld = ::SelectObject(hDCImage, ::GetStockObject(NULL_PEN));
|
|
HGDIOBJ hbrOld = ::SelectObject(hDCImage, ::CreateSolidBrush(crBg));
|
|
::Polygon(hDCImage, m_ptStack, m_iPtSP);
|
|
::DeleteObject(::SelectObject(hDCImage, hbrOld));
|
|
::SelectObject(hDCImage, hPenOld);
|
|
}
|
|
|
|
void SelectionModel::DrawBackgroundRect(HDC hDCImage, COLORREF crBg)
|
|
{
|
|
if (::IsRectEmpty(&m_rcOld))
|
|
return;
|
|
|
|
Rect(hDCImage, m_rcOld.left, m_rcOld.top, m_rcOld.right, m_rcOld.bottom, crBg, crBg, 0, 1);
|
|
}
|
|
|
|
void SelectionModel::DrawBackground(HDC hDCImage)
|
|
{
|
|
if (toolsModel.GetActiveTool() == TOOL_FREESEL)
|
|
DrawBackgroundPoly(hDCImage, paletteModel.GetBgColor());
|
|
else
|
|
DrawBackgroundRect(hDCImage, paletteModel.GetBgColor());
|
|
}
|
|
|
|
void SelectionModel::DrawSelection(HDC hDCImage, COLORREF crBg, BOOL bBgTransparent)
|
|
{
|
|
CRect rc = m_rc;
|
|
if (::IsRectEmpty(&rc))
|
|
return;
|
|
|
|
BITMAP bm;
|
|
if (!GetObject(m_hbmColor, sizeof(BITMAP), &bm))
|
|
return;
|
|
|
|
COLORREF keyColor = (bBgTransparent ? crBg : CLR_INVALID);
|
|
|
|
HDC hMemDC = CreateCompatibleDC(hDCImage);
|
|
HGDIOBJ hbmOld = SelectObject(hMemDC, m_hbmColor);
|
|
ColorKeyedMaskBlt(hDCImage, rc.left, rc.top, rc.Width(), rc.Height(),
|
|
hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, m_hbmMask, keyColor);
|
|
SelectObject(hMemDC, hbmOld);
|
|
DeleteDC(hMemDC);
|
|
}
|
|
|
|
void SelectionModel::GetSelectionContents(HDC hDCImage)
|
|
{
|
|
ClearColor();
|
|
|
|
HDC hMemDC = ::CreateCompatibleDC(NULL);
|
|
m_hbmColor = CreateColorDIB(m_rc.Width(), m_rc.Height(), RGB(255, 255, 255));
|
|
HGDIOBJ hbmOld = ::SelectObject(hMemDC, m_hbmColor);
|
|
::BitBlt(hMemDC, 0, 0, m_rc.Width(), m_rc.Height(), hDCImage, m_rc.left, m_rc.top, SRCCOPY);
|
|
::SelectObject(hMemDC, hbmOld);
|
|
::DeleteDC(hMemDC);
|
|
}
|
|
|
|
BOOL SelectionModel::IsLanded() const
|
|
{
|
|
return !m_hbmColor;
|
|
}
|
|
|
|
BOOL SelectionModel::TakeOff()
|
|
{
|
|
if (!IsLanded() || ::IsRectEmpty(&m_rc))
|
|
return FALSE;
|
|
|
|
m_rgbBack = paletteModel.GetBgColor();
|
|
GetSelectionContents(imageModel.GetDC());
|
|
|
|
if (toolsModel.GetActiveTool() == TOOL_RECTSEL)
|
|
ClearMask();
|
|
|
|
m_rcOld = m_rc;
|
|
|
|
imageModel.NotifyImageChanged();
|
|
return TRUE;
|
|
}
|
|
|
|
void SelectionModel::Landing()
|
|
{
|
|
if (IsLanded() && !m_bShow)
|
|
{
|
|
imageModel.NotifyImageChanged();
|
|
return;
|
|
}
|
|
|
|
m_bShow = FALSE;
|
|
|
|
if (m_bContentChanged ||
|
|
(!::EqualRect(m_rc, m_rcOld) && !::IsRectEmpty(m_rc) && !::IsRectEmpty(m_rcOld)))
|
|
{
|
|
imageModel.PushImageForUndo();
|
|
|
|
canvasWindow.m_drawing = FALSE;
|
|
toolsModel.OnDrawOverlayOnImage(imageModel.GetDC());
|
|
}
|
|
|
|
HideSelection();
|
|
}
|
|
|
|
void SelectionModel::InsertFromHBITMAP(HBITMAP hbmColor, INT x, INT y, HBITMAP hbmMask)
|
|
{
|
|
::DeleteObject(m_hbmColor);
|
|
m_hbmColor = hbmColor;
|
|
|
|
m_rc.left = x;
|
|
m_rc.top = y;
|
|
m_rc.right = x + GetDIBWidth(hbmColor);
|
|
m_rc.bottom = y + GetDIBHeight(hbmColor);
|
|
|
|
if (hbmMask)
|
|
{
|
|
::DeleteObject(m_hbmMask);
|
|
m_hbmMask = hbmMask;
|
|
}
|
|
else
|
|
{
|
|
ClearMask();
|
|
}
|
|
|
|
NotifyContentChanged();
|
|
}
|
|
|
|
void SelectionModel::FlipHorizontally()
|
|
{
|
|
TakeOff();
|
|
|
|
HDC hdcMem = ::CreateCompatibleDC(NULL);
|
|
if (m_hbmMask)
|
|
{
|
|
::SelectObject(hdcMem, m_hbmMask);
|
|
::StretchBlt(hdcMem, m_rc.Width() - 1, 0, -m_rc.Width(), m_rc.Height(),
|
|
hdcMem, 0, 0, m_rc.Width(), m_rc.Height(), SRCCOPY);
|
|
}
|
|
if (m_hbmColor)
|
|
{
|
|
::SelectObject(hdcMem, m_hbmColor);
|
|
::StretchBlt(hdcMem, m_rc.Width() - 1, 0, -m_rc.Width(), m_rc.Height(),
|
|
hdcMem, 0, 0, m_rc.Width(), m_rc.Height(), SRCCOPY);
|
|
}
|
|
::DeleteDC(hdcMem);
|
|
|
|
NotifyContentChanged();
|
|
}
|
|
|
|
void SelectionModel::FlipVertically()
|
|
{
|
|
TakeOff();
|
|
|
|
HDC hdcMem = ::CreateCompatibleDC(NULL);
|
|
if (m_hbmMask)
|
|
{
|
|
::SelectObject(hdcMem, m_hbmMask);
|
|
::StretchBlt(hdcMem, 0, m_rc.Height() - 1, m_rc.Width(), -m_rc.Height(),
|
|
hdcMem, 0, 0, m_rc.Width(), m_rc.Height(), SRCCOPY);
|
|
}
|
|
if (m_hbmColor)
|
|
{
|
|
::SelectObject(hdcMem, m_hbmColor);
|
|
::StretchBlt(hdcMem, 0, m_rc.Height() - 1, m_rc.Width(), -m_rc.Height(),
|
|
hdcMem, 0, 0, m_rc.Width(), m_rc.Height(), SRCCOPY);
|
|
}
|
|
::DeleteDC(hdcMem);
|
|
|
|
NotifyContentChanged();
|
|
}
|
|
|
|
void SelectionModel::RotateNTimes90Degrees(int iN)
|
|
{
|
|
HBITMAP hbm;
|
|
HGDIOBJ hbmOld;
|
|
HDC hdcMem = ::CreateCompatibleDC(NULL);
|
|
|
|
switch (iN)
|
|
{
|
|
case 1: /* rotate 90 degrees */
|
|
case 3: /* rotate 270 degrees */
|
|
TakeOff();
|
|
|
|
if (m_hbmColor)
|
|
{
|
|
hbmOld = ::SelectObject(hdcMem, m_hbmColor);
|
|
hbm = Rotate90DegreeBlt(hdcMem, m_rc.Width(), m_rc.Height(), iN == 1, FALSE);
|
|
::SelectObject(hdcMem, hbmOld);
|
|
::DeleteObject(m_hbmColor);
|
|
m_hbmColor = hbm;
|
|
}
|
|
if (m_hbmMask)
|
|
{
|
|
hbmOld = ::SelectObject(hdcMem, m_hbmMask);
|
|
hbm = Rotate90DegreeBlt(hdcMem, m_rc.Width(), m_rc.Height(), iN == 1, TRUE);
|
|
::SelectObject(hdcMem, hbmOld);
|
|
::DeleteObject(m_hbmMask);
|
|
m_hbmMask = hbm;
|
|
}
|
|
|
|
SwapWidthAndHeight();
|
|
break;
|
|
|
|
case 2: /* rotate 180 degrees */
|
|
TakeOff();
|
|
|
|
if (m_hbmColor)
|
|
{
|
|
hbmOld = ::SelectObject(hdcMem, m_hbmColor);
|
|
::StretchBlt(hdcMem, m_rc.Width() - 1, m_rc.Height() - 1, -m_rc.Width(), -m_rc.Height(),
|
|
hdcMem, 0, 0, m_rc.Width(), m_rc.Height(), SRCCOPY);
|
|
::SelectObject(hdcMem, hbmOld);
|
|
}
|
|
if (m_hbmMask)
|
|
{
|
|
hbmOld = ::SelectObject(hdcMem, m_hbmMask);
|
|
::StretchBlt(hdcMem, m_rc.Width() - 1, m_rc.Height() - 1, -m_rc.Width(), -m_rc.Height(),
|
|
hdcMem, 0, 0, m_rc.Width(), m_rc.Height(), SRCCOPY);
|
|
::SelectObject(hdcMem, hbmOld);
|
|
}
|
|
break;
|
|
}
|
|
|
|
::DeleteDC(hdcMem);
|
|
NotifyContentChanged();
|
|
}
|
|
|
|
static void AttachHBITMAP(HBITMAP *phbm, HBITMAP hbmNew)
|
|
{
|
|
if (hbmNew == NULL)
|
|
return;
|
|
::DeleteObject(*phbm);
|
|
*phbm = hbmNew;
|
|
}
|
|
|
|
void SelectionModel::StretchSkew(int nStretchPercentX, int nStretchPercentY, int nSkewDegX, int nSkewDegY)
|
|
{
|
|
if (nStretchPercentX == 100 && nStretchPercentY == 100 && nSkewDegX == 0 && nSkewDegY == 0)
|
|
return;
|
|
|
|
TakeOff();
|
|
|
|
INT oldWidth = m_rc.Width(), oldHeight = m_rc.Height();
|
|
INT newWidth = oldWidth * nStretchPercentX / 100;
|
|
INT newHeight = oldHeight * nStretchPercentY / 100;
|
|
|
|
HBITMAP hbmColor = m_hbmColor, hbmMask = m_hbmMask;
|
|
|
|
if (hbmMask == NULL)
|
|
hbmMask = CreateMonoBitmap(oldWidth, oldHeight, TRUE);
|
|
|
|
if (oldWidth != newWidth || oldHeight != newHeight)
|
|
{
|
|
AttachHBITMAP(&hbmColor, CopyDIBImage(hbmColor, newWidth, newHeight));
|
|
AttachHBITMAP(&hbmMask, CopyMonoImage(hbmMask, newWidth, newHeight));
|
|
}
|
|
|
|
HGDIOBJ hbmOld;
|
|
HDC hDC = ::CreateCompatibleDC(NULL);
|
|
|
|
if (nSkewDegX)
|
|
{
|
|
hbmOld = ::SelectObject(hDC, hbmColor);
|
|
AttachHBITMAP(&hbmColor, SkewDIB(hDC, hbmColor, nSkewDegX, FALSE));
|
|
::SelectObject(hDC, hbmMask);
|
|
AttachHBITMAP(&hbmMask, SkewDIB(hDC, hbmMask, nSkewDegX, FALSE, TRUE));
|
|
::SelectObject(hDC, hbmOld);
|
|
}
|
|
|
|
if (nSkewDegY)
|
|
{
|
|
hbmOld = ::SelectObject(hDC, hbmColor);
|
|
AttachHBITMAP(&hbmColor, SkewDIB(hDC, hbmColor, nSkewDegY, TRUE));
|
|
::SelectObject(hDC, hbmMask);
|
|
AttachHBITMAP(&hbmMask, SkewDIB(hDC, hbmMask, nSkewDegY, TRUE, TRUE));
|
|
::SelectObject(hDC, hbmOld);
|
|
}
|
|
|
|
::DeleteDC(hDC);
|
|
|
|
InsertFromHBITMAP(hbmColor, m_rc.left, m_rc.top, hbmMask);
|
|
|
|
m_bShow = TRUE;
|
|
NotifyContentChanged();
|
|
}
|
|
|
|
HBITMAP SelectionModel::CopyBitmap()
|
|
{
|
|
if (m_hbmColor == NULL)
|
|
GetSelectionContents(imageModel.GetDC());
|
|
return CopyDIBImage(m_hbmColor);
|
|
}
|
|
|
|
int SelectionModel::PtStackSize() const
|
|
{
|
|
return m_iPtSP;
|
|
}
|
|
|
|
void SelectionModel::DrawFramePoly(HDC hDCImage)
|
|
{
|
|
/* draw the freehand selection inverted/xored */
|
|
Poly(hDCImage, m_ptStack, m_iPtSP, 0, 0, 2, 0, FALSE, TRUE);
|
|
}
|
|
|
|
void SelectionModel::SetRectFromPoints(const POINT& ptFrom, const POINT& ptTo)
|
|
{
|
|
m_rc.left = min(ptFrom.x, ptTo.x);
|
|
m_rc.top = min(ptFrom.y, ptTo.y);
|
|
m_rc.right = max(ptFrom.x, ptTo.x);
|
|
m_rc.bottom = max(ptFrom.y, ptTo.y);
|
|
}
|
|
|
|
void SelectionModel::Dragging(HITTEST hit, POINT pt)
|
|
{
|
|
switch (hit)
|
|
{
|
|
case HIT_NONE:
|
|
break;
|
|
case HIT_UPPER_LEFT:
|
|
m_rc.left += pt.x - m_ptHit.x;
|
|
m_rc.top += pt.y - m_ptHit.y;
|
|
break;
|
|
case HIT_UPPER_CENTER:
|
|
m_rc.top += pt.y - m_ptHit.y;
|
|
break;
|
|
case HIT_UPPER_RIGHT:
|
|
m_rc.right += pt.x - m_ptHit.x;
|
|
m_rc.top += pt.y - m_ptHit.y;
|
|
break;
|
|
case HIT_MIDDLE_LEFT:
|
|
m_rc.left += pt.x - m_ptHit.x;
|
|
break;
|
|
case HIT_MIDDLE_RIGHT:
|
|
m_rc.right += pt.x - m_ptHit.x;
|
|
break;
|
|
case HIT_LOWER_LEFT:
|
|
m_rc.left += pt.x - m_ptHit.x;
|
|
m_rc.bottom += pt.y - m_ptHit.y;
|
|
break;
|
|
case HIT_LOWER_CENTER:
|
|
m_rc.bottom += pt.y - m_ptHit.y;
|
|
break;
|
|
case HIT_LOWER_RIGHT:
|
|
m_rc.right += pt.x - m_ptHit.x;
|
|
m_rc.bottom += pt.y - m_ptHit.y;
|
|
break;
|
|
case HIT_BORDER:
|
|
case HIT_INNER:
|
|
OffsetRect(&m_rc, pt.x - m_ptHit.x, pt.y - m_ptHit.y);
|
|
break;
|
|
}
|
|
m_ptHit = pt;
|
|
}
|
|
|
|
void SelectionModel::ClearMask()
|
|
{
|
|
if (m_hbmMask)
|
|
{
|
|
::DeleteObject(m_hbmMask);
|
|
m_hbmMask = NULL;
|
|
}
|
|
}
|
|
|
|
void SelectionModel::ClearColor()
|
|
{
|
|
if (m_hbmColor)
|
|
{
|
|
::DeleteObject(m_hbmColor);
|
|
m_hbmColor = NULL;
|
|
}
|
|
}
|
|
|
|
void SelectionModel::HideSelection()
|
|
{
|
|
m_bShow = m_bContentChanged = FALSE;
|
|
ClearColor();
|
|
ClearMask();
|
|
::SetRectEmpty(&m_rc);
|
|
::SetRectEmpty(&m_rcOld);
|
|
imageModel.NotifyImageChanged();
|
|
}
|
|
|
|
void SelectionModel::DeleteSelection()
|
|
{
|
|
if (!m_bShow)
|
|
return;
|
|
|
|
TakeOff();
|
|
imageModel.PushImageForUndo();
|
|
DrawBackground(imageModel.GetDC());
|
|
|
|
HideSelection();
|
|
}
|
|
|
|
void SelectionModel::InvertSelection()
|
|
{
|
|
TakeOff();
|
|
|
|
BITMAP bm;
|
|
::GetObject(m_hbmColor, sizeof(bm), &bm);
|
|
|
|
HDC hdc = ::CreateCompatibleDC(NULL);
|
|
HGDIOBJ hbmOld = ::SelectObject(hdc, m_hbmColor);
|
|
RECT rc = { 0, 0, bm.bmWidth, bm.bmHeight };
|
|
::InvertRect(hdc, &rc);
|
|
::SelectObject(hdc, hbmOld);
|
|
::DeleteDC(hdc);
|
|
|
|
NotifyContentChanged();
|
|
}
|
|
|
|
void SelectionModel::NotifyContentChanged()
|
|
{
|
|
m_bContentChanged = TRUE;
|
|
imageModel.NotifyImageChanged();
|
|
}
|
|
|
|
void SelectionModel::SwapWidthAndHeight()
|
|
{
|
|
INT cx = m_rc.Width();
|
|
INT cy = m_rc.Height();
|
|
m_rc.right = m_rc.left + cy;
|
|
m_rc.bottom = m_rc.top + cx;
|
|
}
|