CCanvasWindow Class Reference

#include <canvas.h>

Inheritance diagram for CCanvasWindow:

Collaboration diagram for CCanvasWindow:

Public Member Functions
	DECLARE_WND_CLASS_EX (L"ReactOSPaintCanvas", CS_DBLCLKS|CS_HREDRAW|CS_VREDRAW, COLOR_APPWORKSPACE) CCanvasWindow()
virtual	~CCanvasWindow ()
VOID	OnEndDraw (BOOL bCancel)
VOID	updateScrollRange ()
VOID	updateScrollPos (INT x=0, INT y=0)
VOID	ImageToCanvas (POINT &pt)
VOID	ImageToCanvas (RECT &rc)
VOID	CanvasToImage (POINT &pt)
VOID	CanvasToImage (RECT &rc)
VOID	GetImageRect (RECT &rc)
VOID	getNewZoomRect (CRect &rcView, INT newZoom, CPoint ptTarget)
VOID	zoomTo (INT newZoom, LONG left=0, LONG top=0)

Public Attributes
BOOL	m_drawing

Protected Member Functions
HITTEST	CanvasHitTest (POINT pt)
RECT	GetBaseRect ()
BOOL	DoDraw (HDC hDC, RECT &rcClient, RECT &rcPaint)
VOID	OnHVScroll (WPARAM wParam, INT fnBar)
LRESULT	OnSize (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnHScroll (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnVScroll (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnEraseBkgnd (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnPaint (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnMouseMove (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnKeyDown (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnSetCursor (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnMouseWheel (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnCancelMode (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnCaptureChanged (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnCtlColorEdit (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnPaletteModelColorChanged (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnButtonDown (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnButtonDblClk (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnButtonUp (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

Protected Attributes
HITTEST	m_hitCanvasSizeBox
CStyledCursor	m_hBrushCursor
CStyledCursor	m_hRubberCursor
POINT	m_ptOrig
CRect	m_rcResizing
UINT	m_nMouseDownMsg = 0

Detailed Description

Definition at line 42 of file canvas.h.

Constructor & Destructor Documentation

~CCanvasWindow()

CCanvasWindow::~CCanvasWindow ( )

virtual

Definition at line 154 of file canvas.cpp.

{
}

Member Function Documentation

CanvasHitTest()

HITTEST CCanvasWindow::CanvasHitTest ( POINT  pt )

protected

Definition at line 198 of file canvas.cpp.

{
    if (selectionModel.m_bShow || ::IsWindowVisible(textEditWindow))
        return HIT_INNER;
    RECT rcBase = GetBaseRect();
    return getSizeBoxHitTest(pt, &rcBase);
}

Referenced by OnButtonDown(), and OnSetCursor().

CanvasToImage() [1/2]

VOID CCanvasWindow::CanvasToImage

(

POINT &

pt

)

Definition at line 180 of file canvas.cpp.

{
    pt.x -= GRIP_SIZE - GetScrollPos(SB_HORZ);
    pt.y -= GRIP_SIZE - GetScrollPos(SB_VERT);
    UnZoomed(pt);
}

Referenced by DoDraw(), CTextEditWindow::InvalidateEditRect(), OnButtonDblClk(), OnButtonDown(), OnButtonUp(), OnMouseMove(), and zoomTo().

CanvasToImage() [2/2]

VOID CCanvasWindow::CanvasToImage

(

RECT &

rc

)

Definition at line 187 of file canvas.cpp.

{
    ::OffsetRect(&rc, GetScrollPos(SB_HORZ) - GRIP_SIZE, GetScrollPos(SB_VERT) - GRIP_SIZE);
    UnZoomed(rc);
}

DECLARE_WND_CLASS_EX()

CCanvasWindow::DECLARE_WND_CLASS_EX	(	L"ReactOSPaintCanvas"	,
		CS_DBLCLKS|CS_HREDRAW|	CS_VREDRAW,
		COLOR_APPWORKSPACE
	)

DoDraw()

BOOL CCanvasWindow::DoDraw ( HDC  hDC, RECT &  rcClient, RECT &  rcPaint  )

protected

Definition at line 249 of file canvas.cpp.

{
    // This is the target area we have to draw on
    CRect rcCanvasDraw;
    rcCanvasDraw.IntersectRect(&rcClient, &rcPaint);
 
    // Calculate image size
    CRect rcImage;
    GetImageRect(rcImage);
    SIZE sizeImage = { imageModel.GetWidth(), imageModel.GetHeight() };
 
    // We use a memory bitmap to reduce flickering
    HBITMAP hbmCache1 = CreateDIBWithProperties(rcClient.right, rcClient.bottom);
    if (!hbmCache1)
        return FALSE; // Out of memory
    HBITMAP hbmCache2 = CreateDIBWithProperties(sizeImage.cx, sizeImage.cy);
    if (!hbmCache2)
    {
        ::DeleteObject(hbmCache1);
        return FALSE; // Out of memory
    }
 
    HDC hdcMem0 = ::CreateCompatibleDC(hDC);
    HGDIOBJ hbm0Old = ::SelectObject(hdcMem0, hbmCache1);
 
    // Fill the background on hdcMem0
    ::FillRect(hdcMem0, &rcCanvasDraw, (HBRUSH)(COLOR_APPWORKSPACE + 1));
 
    // Draw the sizeboxes if necessary
    RECT rcBase = GetBaseRect();
    if (!selectionModel.m_bShow && !::IsWindowVisible(textEditWindow))
        drawSizeBoxes(hdcMem0, &rcBase, FALSE, &rcCanvasDraw);
 
    // Calculate the target area on the image
    CRect rcImageDraw = rcCanvasDraw;
    CanvasToImage(rcImageDraw);
    rcImageDraw.IntersectRect(&rcImageDraw, &rcImage);
 
    // Consider rounding down by zooming
    rcImageDraw.right += 1;
    rcImageDraw.bottom += 1;
 
    // hdcMem1 <-- imageModel
    HDC hdcMem1 = ::CreateCompatibleDC(hDC);
    HGDIOBJ hbm1Old = ::SelectObject(hdcMem1, hbmCache2);
    ::BitBlt(hdcMem1, rcImageDraw.left, rcImageDraw.top, rcImageDraw.Width(), rcImageDraw.Height(),
             imageModel.GetDC(), rcImageDraw.left, rcImageDraw.top, SRCCOPY);
 
    // Draw overlay #1 on hdcMem1
    toolsModel.OnDrawOverlayOnImage(hdcMem1);
 
    // Transfer the bits with stretch (hdcMem0 <-- hdcMem1)
    ImageToCanvas(rcImage);
    ::StretchBlt(hdcMem0, rcImage.left, rcImage.top, rcImage.Width(), rcImage.Height(),
                 hdcMem1, 0, 0, sizeImage.cx, sizeImage.cy, SRCCOPY);
 
    // Clean up hdcMem1
    ::SelectObject(hdcMem1, hbm1Old);
    ::DeleteDC(hdcMem1);
 
    // Draw the grid on hdcMem0
    if (g_showGrid && toolsModel.GetZoom() >= 4000)
    {
        HPEN oldPen = (HPEN) ::SelectObject(hdcMem0, ::CreatePen(PS_SOLID, 1, RGB(160, 160, 160)));
        for (INT counter = 0; counter < sizeImage.cy; counter++)
        {
            POINT pt0 = { 0, counter }, pt1 = { sizeImage.cx, counter };
            ImageToCanvas(pt0);
            ImageToCanvas(pt1);
            ::MoveToEx(hdcMem0, pt0.x, pt0.y, NULL);
            ::LineTo(hdcMem0, pt1.x, pt1.y);
        }
        for (INT counter = 0; counter < sizeImage.cx; counter++)
        {
            POINT pt0 = { counter, 0 }, pt1 = { counter, sizeImage.cy };
            ImageToCanvas(pt0);
            ImageToCanvas(pt1);
            ::MoveToEx(hdcMem0, pt0.x, pt0.y, NULL);
            ::LineTo(hdcMem0, pt1.x, pt1.y);
        }
        ::DeleteObject(::SelectObject(hdcMem0, oldPen));
    }
 
    // Draw overlay #2 on hdcMem0
    toolsModel.OnDrawOverlayOnCanvas(hdcMem0);
 
    // Draw new frame on hdcMem0 if any
    if (m_hitCanvasSizeBox != HIT_NONE && !m_rcResizing.IsRectEmpty())
        DrawXorRect(hdcMem0, &m_rcResizing);
 
    // Transfer the bits (hDC <-- hdcMem0)
    ::BitBlt(hDC, rcCanvasDraw.left, rcCanvasDraw.top, rcCanvasDraw.Width(), rcCanvasDraw.Height(),
             hdcMem0, rcCanvasDraw.left, rcCanvasDraw.top, SRCCOPY);
 
    // Clean up hdcMem0
    ::SelectObject(hdcMem0, hbm0Old);
    ::DeleteDC(hdcMem0);
    ::DeleteObject(hbmCache2);
    ::DeleteObject(hbmCache1);
 
    return TRUE;
}

Referenced by OnPaint().

GetBaseRect()

RECT CCanvasWindow::GetBaseRect ( )

protected

Definition at line 158 of file canvas.cpp.

{
    CRect rcBase;
    GetImageRect(rcBase);
    ImageToCanvas(rcBase);
    rcBase.InflateRect(GRIP_SIZE, GRIP_SIZE);
    return rcBase;
}

Referenced by CanvasHitTest(), and DoDraw().

GetImageRect()

VOID CCanvasWindow::GetImageRect

(

RECT &

rc

)

Definition at line 193 of file canvas.cpp.

{
    rc = { 0, 0, imageModel.GetWidth(), imageModel.GetHeight() };
}

Referenced by DoDraw(), GetBaseRect(), ZoomTool::getNewZoomRect(), getNewZoomRect(), OnMouseMove(), CTextEditWindow::OnMoving(), OnSetCursor(), and CTextEditWindow::OnSizing().

getNewZoomRect()

VOID CCanvasWindow::getNewZoomRect	(	CRect &	rcView,
		INT	newZoom,
		CPoint	ptTarget
	)

Definition at line 206 of file canvas.cpp.

{
    CRect rcImage;
    GetImageRect(rcImage);
    ImageToCanvas(rcImage);
 
    // Calculate the zoom rectangle
    INT oldZoom = toolsModel.GetZoom();
    GetClientRect(rcView);
    LONG cxView = rcView.right * oldZoom / newZoom, cyView = rcView.bottom * oldZoom / newZoom;
    rcView.SetRect(ptTarget.x - cxView / 2, ptTarget.y - cyView / 2,
                   ptTarget.x + cxView / 2, ptTarget.y + cyView / 2);
 
    // Shift the rectangle if necessary
    INT dx = 0, dy = 0;
    if (rcView.left < rcImage.left)
        dx = rcImage.left - rcView.left;
    else if (rcImage.right < rcView.right)
        dx = rcImage.right - rcView.right;
    if (rcView.top < rcImage.top)
        dy = rcImage.top - rcView.top;
    else if (rcImage.bottom < rcView.bottom)
        dy = rcImage.bottom - rcView.bottom;
    rcView.OffsetRect(dx, dy);
 
    rcView.IntersectRect(&rcView, &rcImage);
}

Referenced by ZoomTool::getNewZoomRect().

ImageToCanvas() [1/2]

VOID CCanvasWindow::ImageToCanvas

(

POINT &

pt

)

Definition at line 167 of file canvas.cpp.

{
    Zoomed(pt);
    pt.x += GRIP_SIZE - GetScrollPos(SB_HORZ);
    pt.y += GRIP_SIZE - GetScrollPos(SB_VERT);
}

Referenced by DoDraw(), SelectionModel::drawFrameOnCanvas(), GetBaseRect(), ZoomTool::getNewZoomRect(), getNewZoomRect(), SelectionModel::hitTest(), SelectionBaseTool::OnButtonDown(), OnMouseMove(), CTextEditWindow::OnMoving(), OnSetCursor(), CTextEditWindow::OnSizing(), CTextEditWindow::ValidateEditRect(), and zoomTo().

ImageToCanvas() [2/2]

VOID CCanvasWindow::ImageToCanvas

(

RECT &

rc

)

Definition at line 174 of file canvas.cpp.

{
    Zoomed(rc);
    ::OffsetRect(&rc, GRIP_SIZE - GetScrollPos(SB_HORZ), GRIP_SIZE - GetScrollPos(SB_VERT));
}

OnButtonDblClk()

LRESULT CCanvasWindow::OnButtonDblClk ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 511 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
    CanvasToImage(pt);
 
    m_drawing = FALSE;
    ::ReleaseCapture();
    m_nMouseDownMsg = 0;
 
    toolsModel.OnButtonDown(nMsg == WM_LBUTTONDBLCLK, pt.x, pt.y, TRUE);
    toolsModel.resetTool();
    Invalidate();
    return 0;
}

OnButtonDown()

LRESULT CCanvasWindow::OnButtonDown ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 439 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
 
    m_nMouseDownMsg = nMsg;
    BOOL bLeftButton = (nMsg == WM_LBUTTONDOWN);
 
    if (nMsg == WM_MBUTTONDOWN)
    {
        m_ptOrig = pt;
        SetCapture();
        ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_HANDDRAG)));
        return 0;
    }
 
    HITTEST hitSelection = selectionModel.hitTest(pt);
    if (hitSelection != HIT_NONE)
    {
        m_drawing = TRUE;
        CanvasToImage(pt);
        SetCapture();
        toolsModel.OnButtonDown(bLeftButton, pt.x, pt.y, FALSE);
        Invalidate();
        return 0;
    }
 
    HITTEST hit = CanvasHitTest(pt);
    if (hit == HIT_NONE || hit == HIT_BORDER)
    {
        switch (toolsModel.GetActiveTool())
        {
            case TOOL_BEZIER:
            case TOOL_SHAPE:
                toolsModel.OnEndDraw(TRUE);
                Invalidate();
                break;
 
            case TOOL_FREESEL:
            case TOOL_RECTSEL:
                toolsModel.OnEndDraw(FALSE);
                Invalidate();
                break;
 
            default:
                break;
        }
 
        toolsModel.resetTool(); // resets the point-buffer of the polygon and bezier functions
        return 0;
    }
 
    CanvasToImage(pt);
 
    if (hit == HIT_INNER)
    {
        m_drawing = TRUE;
        SetCapture();
        toolsModel.OnButtonDown(bLeftButton, pt.x, pt.y, FALSE);
        Invalidate();
        return 0;
    }
 
    if (bLeftButton)
    {
        m_hitCanvasSizeBox = hit;
        m_ptOrig = pt;
        SetCapture();
    }
 
    return 0;
}

OnButtonUp()

LRESULT CCanvasWindow::OnButtonUp ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 652 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
    CanvasToImage(pt);
 
    ::ReleaseCapture();
 
    BOOL bLeftButton = (m_nMouseDownMsg == WM_LBUTTONDOWN);
    m_nMouseDownMsg = 0;
 
    if (m_drawing)
    {
        m_drawing = FALSE;
        toolsModel.OnButtonUp(bLeftButton, pt.x, pt.y);
        Invalidate(FALSE);
        ::SendMessageW(g_hStatusBar, SB_SETTEXT, 2, (LPARAM)L"");
        return 0;
    }
 
    if (m_hitCanvasSizeBox == HIT_NONE || !bLeftButton)
        return 0;
 
    // Resize the image
    INT cxImage = imageModel.GetWidth(), cyImage = imageModel.GetHeight();
    INT cxDelta = pt.x - m_ptOrig.x;
    INT cyDelta = pt.y - m_ptOrig.y;
    switch (m_hitCanvasSizeBox)
    {
        case HIT_UPPER_LEFT:
            imageModel.Crop(cxImage - cxDelta, cyImage - cyDelta, cxDelta, cyDelta);
            break;
        case HIT_UPPER_CENTER:
            imageModel.Crop(cxImage, cyImage - cyDelta, 0, cyDelta);
            break;
        case HIT_UPPER_RIGHT:
            imageModel.Crop(cxImage + cxDelta, cyImage - cyDelta, 0, cyDelta);
            break;
        case HIT_MIDDLE_LEFT:
            imageModel.Crop(cxImage - cxDelta, cyImage, cxDelta, 0);
            break;
        case HIT_MIDDLE_RIGHT:
            imageModel.Crop(cxImage + cxDelta, cyImage, 0, 0);
            break;
        case HIT_LOWER_LEFT:
            imageModel.Crop(cxImage - cxDelta, cyImage + cyDelta, cxDelta, 0);
            break;
        case HIT_LOWER_CENTER:
            imageModel.Crop(cxImage, cyImage + cyDelta, 0, 0);
            break;
        case HIT_LOWER_RIGHT:
            imageModel.Crop(cxImage + cxDelta, cyImage + cyDelta, 0, 0);
            break;
        default:
            break;
    }
    m_rcResizing.SetRectEmpty();
 
    g_imageSaved = FALSE;
 
    m_hitCanvasSizeBox = HIT_NONE;
    toolsModel.resetTool(); // resets the point-buffer of the polygon and bezier functions
    updateScrollRange();
    Invalidate(TRUE);
    return 0;
}

OnCancelMode()

LRESULT CCanvasWindow::OnCancelMode ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 818 of file canvas.cpp.

{
    // Cancel dragging
    m_hitCanvasSizeBox = HIT_NONE;
    m_rcResizing.SetRectEmpty();
    Invalidate(TRUE);
    return 0;
}

OnCaptureChanged()

LRESULT CCanvasWindow::OnCaptureChanged ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 832 of file canvas.cpp.

{
    ::SendMessageW(g_hStatusBar, SB_SETTEXT, 2, (LPARAM)L"");
    return 0;
}

OnCtlColorEdit()

LRESULT CCanvasWindow::OnCtlColorEdit ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 875 of file canvas.cpp.

{
    SetTextColor((HDC)wParam, paletteModel.GetFgColor());
    SetBkMode((HDC)wParam, TRANSPARENT);
    return (LRESULT)GetStockObject(NULL_BRUSH);
}

OnEndDraw()

VOID CCanvasWindow::OnEndDraw

(

BOOL

bCancel

)

Definition at line 868 of file canvas.cpp.

{
    m_drawing = FALSE;
    toolsModel.OnEndDraw(bCancel);
    Invalidate(FALSE);
}

Referenced by CMainWindow::ConfirmSave(), CMainWindow::OnCommand(), OnKeyDown(), and CMainWindow::saveImage().

OnEraseBkgnd()

LRESULT CCanvasWindow::OnEraseBkgnd ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 838 of file canvas.cpp.

{
    return TRUE; // do nothing => transparent background
}

OnHScroll()

LRESULT CCanvasWindow::OnHScroll ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 427 of file canvas.cpp.

{
    OnHVScroll(wParam, SB_HORZ);
    return 0;
}

OnHVScroll()

VOID CCanvasWindow::OnHVScroll ( WPARAM  wParam, INT  fnBar  )

protected

Definition at line 397 of file canvas.cpp.

{
    SCROLLINFO si;
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_ALL;
    GetScrollInfo(fnBar, &si);
    switch (LOWORD(wParam))
    {
        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            si.nPos = (SHORT)HIWORD(wParam);
            break;
        case SB_LINELEFT:
            si.nPos -= 5;
            break;
        case SB_LINERIGHT:
            si.nPos += 5;
            break;
        case SB_PAGELEFT:
            si.nPos -= si.nPage;
            break;
        case SB_PAGERIGHT:
            si.nPos += si.nPage;
            break;
    }
    si.nPos = max(min(si.nPos, si.nMax), si.nMin);
    SetScrollInfo(fnBar, &si);
    Invalidate();
}

Referenced by OnHScroll(), and OnVScroll().

OnKeyDown()

LRESULT CCanvasWindow::OnKeyDown ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 803 of file canvas.cpp.

{
    if (wParam == VK_ESCAPE)
    {
        OnEndDraw(TRUE);
        ::ReleaseCapture();
        m_nMouseDownMsg = 0;
        m_hitCanvasSizeBox = HIT_NONE;
        m_rcResizing.SetRectEmpty();
        Invalidate(TRUE);
    }
 
    return 0;
}

OnMouseMove()

LRESULT CCanvasWindow::OnMouseMove ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 526 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
 
    if (m_nMouseDownMsg == WM_MBUTTONDOWN)
    {
        INT x = GetScrollPos(SB_HORZ) - (pt.x - m_ptOrig.x);
        INT y = GetScrollPos(SB_VERT) - (pt.y - m_ptOrig.y);
        SendMessage(WM_HSCROLL, MAKEWPARAM(SB_THUMBPOSITION, x), 0);
        SendMessage(WM_VSCROLL, MAKEWPARAM(SB_THUMBPOSITION, y), 0);
        m_ptOrig = pt;
        return 0;
    }
 
    CanvasToImage(pt);
 
    if (toolsModel.GetActiveTool() == TOOL_ZOOM)
        Invalidate();
 
    if (!m_drawing || toolsModel.GetActiveTool() <= TOOL_AIRBRUSH)
    {
        TRACKMOUSEEVENT tme = { sizeof(tme) };
        tme.dwFlags = TME_LEAVE;
        tme.hwndTrack = m_hWnd;
        tme.dwHoverTime = 0;
        ::TrackMouseEvent(&tme);
 
        if (!m_drawing)
        {
            CRect rcImage;
            GetImageRect(rcImage);
 
            CStringW strCoord;
            if (rcImage.PtInRect(pt))
                strCoord.Format(L"%ld, %ld", pt.x, pt.y);
            ::SendMessageW(g_hStatusBar, SB_SETTEXT, 1, (LPARAM)(LPCWSTR)strCoord);
        }
    }
 
    if (m_drawing || toolsModel.IsSelection())
    {
        toolsModel.DrawWithMouseTool(pt, wParam);
        return 0;
    }
 
    if (m_hitCanvasSizeBox == HIT_NONE || ::GetCapture() != m_hWnd)
        return 0;
 
    // Dragging now... Calculate the new size
    INT cxImage = imageModel.GetWidth(), cyImage = imageModel.GetHeight();
    INT cxDelta = pt.x - m_ptOrig.x;
    INT cyDelta = pt.y - m_ptOrig.y;
    switch (m_hitCanvasSizeBox)
    {
        case HIT_UPPER_LEFT:
            cxImage -= cxDelta;
            cyImage -= cyDelta;
            break;
        case HIT_UPPER_CENTER:
            cyImage -= cyDelta;
            break;
        case HIT_UPPER_RIGHT:
            cxImage += cxDelta;
            cyImage -= cyDelta;
            break;
        case HIT_MIDDLE_LEFT:
            cxImage -= cxDelta;
            break;
        case HIT_MIDDLE_RIGHT:
            cxImage += cxDelta;
            break;
        case HIT_LOWER_LEFT:
            cxImage -= cxDelta;
            cyImage += cyDelta;
            break;
        case HIT_LOWER_CENTER:
            cyImage += cyDelta;
            break;
        case HIT_LOWER_RIGHT:
            cxImage += cxDelta;
            cyImage += cyDelta;
            break;
        default:
            return 0;
    }
 
    // Limit bitmap size
    cxImage = max(1, cxImage);
    cyImage = max(1, cyImage);
    cxImage = min(MAXWORD, cxImage);
    cyImage = min(MAXWORD, cyImage);
 
    // Display new size
    CStringW strSize;
    strSize.Format(L"%d x %d", cxImage, cyImage);
    ::SendMessageW(g_hStatusBar, SB_SETTEXT, 2, (LPARAM)(LPCWSTR)strSize);
 
    // Dragging now... Fix the position...
    CRect rcResizing = { 0, 0, cxImage, cyImage };
    switch (m_hitCanvasSizeBox)
    {
        case HIT_UPPER_LEFT:
            rcResizing.OffsetRect(cxDelta, cyDelta);
            break;
        case HIT_UPPER_CENTER:
            rcResizing.OffsetRect(0, cyDelta);
            break;
        case HIT_UPPER_RIGHT:
            rcResizing.OffsetRect(0, cyDelta);
            break;
        case HIT_MIDDLE_LEFT:
            rcResizing.OffsetRect(cxDelta, 0);
            break;
        case HIT_LOWER_LEFT:
            rcResizing.OffsetRect(cxDelta, 0);
            break;
        default:
            break;
    }
    ImageToCanvas(rcResizing);
    m_rcResizing = rcResizing;
    Invalidate(TRUE);
 
    return 0;
}

OnMouseWheel()

LRESULT CCanvasWindow::OnMouseWheel ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 827 of file canvas.cpp.

{
    return ::SendMessageW(GetParent(), nMsg, wParam, lParam);
}

OnPaint()

LRESULT CCanvasWindow::OnPaint ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 843 of file canvas.cpp.

{
    RECT rcClient;
    GetClientRect(&rcClient);
 
    static BOOL s_bShowedOutOfMemory = FALSE; // Don't show "Out Of Memory" message multiple time
 
    PAINTSTRUCT ps;
    HDC hDC = BeginPaint(&ps);
 
    if (DoDraw(hDC, rcClient, ps.rcPaint))
    {
        s_bShowedOutOfMemory = FALSE;
    }
    else if (!s_bShowedOutOfMemory)
    {
        ShowOutOfMemory();
        s_bShowedOutOfMemory = TRUE;
        imageModel.ClearHistory(); // Reduce memory usage
    }
 
    EndPaint(&ps);
    return 0;
}

OnPaletteModelColorChanged()

LRESULT CCanvasWindow::OnPaletteModelColorChanged ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 882 of file canvas.cpp.

{
    imageModel.NotifyImageChanged();
    return 0;
}

OnSetCursor()

LRESULT CCanvasWindow::OnSetCursor ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 718 of file canvas.cpp.

{
    if (CWaitCursor::IsWaiting())
    {
        bHandled = FALSE;
        return 0;
    }
 
    if (m_nMouseDownMsg == WM_MBUTTONDOWN)
    {
        ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_HANDDRAG)));
        return 0;
    }
 
    POINT pt;
    ::GetCursorPos(&pt);
    ScreenToClient(&pt);
 
    CRect rcClient;
    GetClientRect(&rcClient);
 
    if (!rcClient.PtInRect(pt))
    {
        bHandled = FALSE;
        return 0;
    }
 
    HITTEST hitSelection = selectionModel.hitTest(pt);
    if (hitSelection != HIT_NONE)
    {
        if (!setCursorOnSizeBox(hitSelection))
            ::SetCursor(::LoadCursorW(NULL, (LPCWSTR)IDC_SIZEALL));
        return 0;
    }
 
    CRect rcImage;
    GetImageRect(rcImage);
    ImageToCanvas(rcImage);
 
    if (rcImage.PtInRect(pt))
    {
        switch (toolsModel.GetActiveTool())
        {
            case TOOL_FILL:
                ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_FILL)));
                break;
            case TOOL_COLOR:
                ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_COLOR)));
                break;
            case TOOL_ZOOM:
                ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_ZOOM)));
                break;
            case TOOL_PEN:
                ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_PEN)));
                break;
            case TOOL_AIRBRUSH:
                ::SetCursor(::LoadCursorW(g_hinstExe, MAKEINTRESOURCEW(IDC_AIRBRUSH)));
                break;
            case TOOL_RUBBER:
            {
                m_hRubberCursor.SetStyle(BrushStyleSquare, toolsModel.GetRubberRadius(),
                                         paletteModel.GetBgColor(), TRUE);
                m_hRubberCursor.SetCursor();
                break;
            }
            case TOOL_BRUSH:
            {
                m_hBrushCursor.SetStyle(toolsModel.GetBrushStyle(),
                                        toolsModel.GetBrushWidth() / 2,
                                        paletteModel.GetFgColor(), FALSE);
                m_hBrushCursor.SetCursor();
                break;
            }
            default:
                ::SetCursor(::LoadCursorW(NULL, (LPCWSTR)IDC_CROSS));
        }
        return 0;
    }
 
    if (selectionModel.m_bShow || !setCursorOnSizeBox(CanvasHitTest(pt)))
        bHandled = FALSE;
 
    return 0;
}

OnSize()

LRESULT CCanvasWindow::OnSize ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 389 of file canvas.cpp.

{
    if (m_hWnd)
        updateScrollRange();
 
    return 0;
}

OnVScroll()

LRESULT CCanvasWindow::OnVScroll ( UINT  nMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

protected

Definition at line 433 of file canvas.cpp.

{
    OnHVScroll(wParam, SB_VERT);
    return 0;
}

updateScrollPos()

VOID CCanvasWindow::updateScrollPos	(	INT	x = 0,
		INT	y = 0
	)

Definition at line 383 of file canvas.cpp.

{
    SetScrollPos(SB_HORZ, x);
    SetScrollPos(SB_VERT, y);
}

Referenced by CMainWindow::OnCommand(), SetBitmapAndInfo(), and zoomTo().

updateScrollRange()

VOID CCanvasWindow::updateScrollRange

(

)

Definition at line 352 of file canvas.cpp.

{
    CRect rcClient;
    GetClientRect(&rcClient);
 
    CSize sizePage(rcClient.right, rcClient.bottom);
    CSize sizeZoomed = { Zoomed(imageModel.GetWidth()), Zoomed(imageModel.GetHeight()) };
    CSize sizeWhole = { sizeZoomed.cx + (GRIP_SIZE * 2), sizeZoomed.cy + (GRIP_SIZE * 2) };
 
    // show/hide the scrollbars
    ShowScrollBar(SB_HORZ, sizePage.cx < sizeWhole.cx);
    ShowScrollBar(SB_VERT, sizePage.cy < sizeWhole.cy);
 
    if (sizePage.cx < sizeWhole.cx || sizePage.cy < sizeWhole.cy)
    {
        GetClientRect(&rcClient); // Scrollbars might change, get client rectangle again
        sizePage = CSize(rcClient.right, rcClient.bottom);
    }
 
    SCROLLINFO si = { sizeof(si), SIF_PAGE | SIF_RANGE };
    si.nMin   = 0;
 
    si.nMax   = sizeWhole.cx;
    si.nPage  = sizePage.cx;
    SetScrollInfo(SB_HORZ, &si);
 
    si.nMax   = sizeWhole.cy;
    si.nPage  = sizePage.cy;
    SetScrollInfo(SB_VERT, &si);
}

Referenced by ImageModel::NotifyImageChanged(), OnButtonUp(), OnSize(), and zoomTo().

zoomTo()

VOID CCanvasWindow::zoomTo	(	INT	newZoom,
		LONG	left = 0,
		LONG	top = 0
	)

Definition at line 234 of file canvas.cpp.

{
    POINT pt = { left, top };
    CanvasToImage(pt);
 
    toolsModel.SetZoom(newZoom);
    ImageToCanvas(pt);
    pt.x += GetScrollPos(SB_HORZ);
    pt.y += GetScrollPos(SB_VERT);
 
    updateScrollRange();
    updateScrollPos(pt.x, pt.y);
    Invalidate(TRUE);
}

Referenced by ZoomTool::OnButtonDown(), CMainWindow::OnCommand(), CMainWindow::OnMouseWheel(), and CToolSettingsWindow::OnVScroll().

Member Data Documentation

m_drawing

BOOL CCanvasWindow::m_drawing

Definition at line 75 of file canvas.h.

Referenced by SelectionModel::Landing(), OnButtonDblClk(), OnButtonDown(), OnButtonUp(), CMainWindow::OnCommand(), TextTool::OnDrawOverlayOnImage(), OnEndDraw(), and OnMouseMove().

m_hBrushCursor

CStyledCursor CCanvasWindow::m_hBrushCursor

protected

Definition at line 91 of file canvas.h.

Referenced by OnSetCursor().

m_hitCanvasSizeBox

HITTEST CCanvasWindow::m_hitCanvasSizeBox

protected

Definition at line 90 of file canvas.h.

Referenced by DoDraw(), OnButtonDown(), OnButtonUp(), OnCancelMode(), OnKeyDown(), and OnMouseMove().

m_hRubberCursor

CStyledCursor CCanvasWindow::m_hRubberCursor

protected

Definition at line 92 of file canvas.h.

Referenced by OnSetCursor().

m_nMouseDownMsg

UINT CCanvasWindow::m_nMouseDownMsg = 0

protected

Definition at line 115 of file canvas.h.

Referenced by OnButtonDblClk(), OnButtonDown(), OnButtonUp(), OnKeyDown(), OnMouseMove(), and OnSetCursor().

m_ptOrig

POINT CCanvasWindow::m_ptOrig

protected

Definition at line 93 of file canvas.h.

Referenced by OnButtonDown(), OnButtonUp(), and OnMouseMove().

m_rcResizing

CRect CCanvasWindow::m_rcResizing

protected

Definition at line 94 of file canvas.h.

Referenced by DoDraw(), OnButtonUp(), OnCancelMode(), OnKeyDown(), and OnMouseMove().

---

The documentation for this class was generated from the following files:

• base/applications/mspaint/canvas.h
• base/applications/mspaint/canvas.cpp