CCanvasWindow Class Reference

#include <canvas.h>

Inheritance diagram for CCanvasWindow:

Collaboration diagram for CCanvasWindow:

Public Member Functions
	CCanvasWindow ()
VOID	cancelDrawing ()
VOID	finishDrawing ()
VOID	Update (HWND hwndFrom)
VOID	ImageToCanvas (POINT &pt)
VOID	ImageToCanvas (RECT &rc)
VOID	CanvasToImage (POINT &pt, BOOL bZoomed=FALSE)
VOID	CanvasToImage (RECT &rc, BOOL bZoomed=FALSE)
VOID	GetImageRect (RECT &rc)

Public Attributes
BOOL	m_drawing

Protected Member Functions
CANVAS_HITTEST	CanvasHitTest (POINT pt)
RECT	GetBaseRect ()
VOID	DoDraw (HDC hDC, RECT &rcClient, RECT &rcPaint)
VOID	OnHVScroll (WPARAM wParam, INT fnBar)
VOID	drawZoomFrame (INT mouseX, INT mouseY)
CANVAS_HITTEST	SelectionHitTest (POINT ptZoomed)
VOID	StartSelectionDrag (CANVAS_HITTEST hit, POINT ptUnZoomed)
VOID	SelectionDragging (POINT ptUnZoomed)
VOID	EndSelectionDrag (POINT ptUnZoomed)
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	OnLButtonDown (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnRButtonDown (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnLButtonDblClk (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnRButtonDblClk (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	OnLButtonUp (UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnRButtonUp (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	OnLRButtonDown (BOOL bLeftButton, UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnLRButtonDblClk (BOOL bLeftButton, UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnLRButtonUp (BOOL bLeftButton, UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

Protected Attributes
CANVAS_HITTEST	m_hitSelection
CANVAS_HITTEST	m_whereHit
POINT	m_ptOrig
CRect	m_rcNew

Detailed Description

Definition at line 11 of file canvas.h.

Constructor & Destructor Documentation

CCanvasWindow()

CCanvasWindow::CCanvasWindow

(

)

Definition at line 15 of file canvas.cpp.

    : m_drawing(FALSE)
    , m_hitSelection(HIT_NONE)
    , m_whereHit(HIT_NONE)
    , m_ptOrig { -1, -1 }
{
    ::SetRectEmpty(&m_rcNew);
}

Member Function Documentation

cancelDrawing()

VOID CCanvasWindow::cancelDrawing

(

)

Definition at line 717 of file canvas.cpp.

{
    selectionModel.ClearColor();
    selectionModel.ClearMask();
    m_hitSelection = HIT_NONE;
    m_drawing = FALSE;
    toolsModel.OnCancelDraw();
    Invalidate(FALSE);
}

Referenced by CMainWindow::OnCommand().

CanvasHitTest()

CANVAS_HITTEST CCanvasWindow::CanvasHitTest ( POINT  pt )

protected

Definition at line 88 of file canvas.cpp.

{
    RECT rcBase = GetBaseRect();
    return getSizeBoxHitTest(pt, &rcBase);
}

Referenced by OnLRButtonDown(), and OnSetCursor().

CanvasToImage() [1/2]

VOID CCanvasWindow::CanvasToImage	(	POINT &	pt,
		BOOL	bZoomed = FALSE
	)

Definition at line 62 of file canvas.cpp.

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

Referenced by CTextEditWindow::InvalidateEditRect(), OnLRButtonDblClk(), OnLRButtonDown(), OnLRButtonUp(), OnMouseMove(), and CTextEditWindow::Reposition().

CanvasToImage() [2/2]

VOID CCanvasWindow::CanvasToImage	(	RECT &	rc,
		BOOL	bZoomed = FALSE
	)

Definition at line 72 of file canvas.cpp.

{
    ::OffsetRect(&rc, GetScrollPos(SB_HORZ) - GRIP_SIZE, GetScrollPos(SB_VERT) - GRIP_SIZE);
    if (bZoomed)
        return;
    rc.left = UnZoomed(rc.left);
    rc.top = UnZoomed(rc.top);
    rc.right = UnZoomed(rc.right);
    rc.bottom = UnZoomed(rc.bottom);
}

DoDraw()

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

protected

Definition at line 94 of file canvas.cpp.

{
    // We use a memory bitmap to reduce flickering
    HDC hdcMem = ::CreateCompatibleDC(hDC);
    HBITMAP hbm = ::CreateCompatibleBitmap(hDC, rcClient.right, rcClient.bottom);
    HGDIOBJ hbmOld = ::SelectObject(hdcMem, hbm);
 
    // Fill the background
    ::FillRect(hdcMem, &rcPaint, (HBRUSH)(COLOR_APPWORKSPACE + 1));
 
    // Draw the sizeboxes if necessary
    RECT rcBase = GetBaseRect();
    if (!selectionModel.m_bShow)
        drawSizeBoxes(hdcMem, &rcBase, FALSE, &rcPaint);
 
    // Draw the image
    CRect rcImage;
    GetImageRect(rcImage);
    ImageToCanvas(rcImage);
    SIZE sizeImage = { imageModel.GetWidth(), imageModel.GetHeight() };
    StretchBlt(hdcMem, rcImage.left, rcImage.top, rcImage.Width(), rcImage.Height(),
               imageModel.GetDC(), 0, 0, sizeImage.cx, sizeImage.cy, SRCCOPY);
 
    // Draw the grid
    if (showGrid && toolsModel.GetZoom() >= 4000)
    {
        HPEN oldPen = (HPEN) SelectObject(hdcMem, 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(hdcMem, pt0.x, pt0.y, NULL);
            ::LineTo(hdcMem, 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(hdcMem, pt0.x, pt0.y, NULL);
            ::LineTo(hdcMem, pt1.x, pt1.y);
        }
        ::DeleteObject(::SelectObject(hdcMem, oldPen));
    }
 
    // Draw selection
    if (selectionModel.m_bShow)
    {
        RECT rcSelection = selectionModel.m_rc;
        ImageToCanvas(rcSelection);
 
        ::InflateRect(&rcSelection, GRIP_SIZE, GRIP_SIZE);
        drawSizeBoxes(hdcMem, &rcSelection, TRUE, &rcPaint);
        ::InflateRect(&rcSelection, -GRIP_SIZE, -GRIP_SIZE);
 
        INT iSaveDC = ::SaveDC(hdcMem);
        ::IntersectClipRect(hdcMem, rcImage.left, rcImage.top, rcImage.right, rcImage.bottom);
        selectionModel.DrawSelection(hdcMem, &rcSelection, paletteModel.GetBgColor(),
                                     toolsModel.IsBackgroundTransparent());
        ::RestoreDC(hdcMem, iSaveDC);
    }
 
    // Draw new frame if any
    if (m_whereHit != HIT_NONE && !::IsRectEmpty(&m_rcNew))
        DrawXorRect(hdcMem, &m_rcNew);
 
    // Transfer the bits
    ::BitBlt(hDC,
             rcPaint.left, rcPaint.top,
             rcPaint.right - rcPaint.left, rcPaint.bottom - rcPaint.top,
             hdcMem, rcPaint.left, rcPaint.top, SRCCOPY);
 
    ::DeleteObject(::SelectObject(hdcMem, hbmOld));
    ::DeleteDC(hdcMem);
}

Referenced by OnPaint().

drawZoomFrame()

VOID CCanvasWindow::drawZoomFrame ( INT  mouseX, INT  mouseY  )

protected

Definition at line 24 of file canvas.cpp.

{
    // FIXME: Draw the border of the area that is to be zoomed in
    CRect rc;
    GetImageRect(rc);
    ImageToCanvas(rc);
 
    HDC hdc = GetDC();
    DrawXorRect(hdc, &rc);
    ReleaseDC(hdc);
}

Referenced by OnMouseMove().

EndSelectionDrag()

VOID CCanvasWindow::EndSelectionDrag ( POINT  ptUnZoomed )

protected

Definition at line 763 of file canvas.cpp.

{
    selectionModel.Dragging(m_hitSelection, ptUnZoomed);
    m_hitSelection = HIT_NONE;
    Invalidate(FALSE);
}

Referenced by OnLRButtonUp().

finishDrawing()

VOID CCanvasWindow::finishDrawing

(

)

Definition at line 727 of file canvas.cpp.

{
    toolsModel.OnFinishDraw();
    m_drawing = FALSE;
    Invalidate(FALSE);
}

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

GetBaseRect()

RECT CCanvasWindow::GetBaseRect ( )

protected

Definition at line 36 of file canvas.cpp.

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

Referenced by CanvasHitTest(), and DoDraw().

GetImageRect()

VOID CCanvasWindow::GetImageRect

(

RECT &

rc

)

Definition at line 83 of file canvas.cpp.

{
    ::SetRect(&rc, 0, 0, imageModel.GetWidth(), imageModel.GetHeight());
}

Referenced by DoDraw(), drawZoomFrame(), GetBaseRect(), OnSetCursor(), and CTextEditWindow::Reposition().

ImageToCanvas() [1/2]

VOID CCanvasWindow::ImageToCanvas

(

POINT &

pt

)

Definition at line 45 of file canvas.cpp.

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

Referenced by DoDraw(), drawZoomFrame(), GetBaseRect(), OnMouseMove(), OnSetCursor(), CTextEditWindow::Reposition(), and CTextEditWindow::ValidateEditRect().

ImageToCanvas() [2/2]

VOID CCanvasWindow::ImageToCanvas

(

RECT &

rc

)

Definition at line 53 of file canvas.cpp.

{
    rc.left = Zoomed(rc.left);
    rc.top = Zoomed(rc.top);
    rc.right = Zoomed(rc.right);
    rc.bottom = Zoomed(rc.bottom);
    ::OffsetRect(&rc, GRIP_SIZE - GetScrollPos(SB_HORZ), GRIP_SIZE - GetScrollPos(SB_VERT));
}

OnCancelMode()

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

protected

Definition at line 680 of file canvas.cpp.

{
    // Cancel dragging
    m_whereHit = HIT_NONE;
    ::SetRectEmpty(&m_rcNew);
    Invalidate(TRUE);
    return 0;
}

OnCaptureChanged()

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

protected

Definition at line 694 of file canvas.cpp.

{
    SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM)_T(""));
    return 0;
}

OnEraseBkgnd()

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

protected

Definition at line 700 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 240 of file canvas.cpp.

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

OnHVScroll()

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

protected

Definition at line 210 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 = 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;
    }
    SetScrollInfo(fnBar, &si);
    Update(m_hWnd);
    Invalidate(FALSE); // FIXME: Flicker
}

Referenced by OnHScroll(), and OnVScroll().

OnKeyDown()

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

protected

Definition at line 666 of file canvas.cpp.

{
    if (wParam == VK_ESCAPE && ::GetCapture() == m_hWnd)
    {
        // Cancel dragging
        ::ReleaseCapture();
        m_whereHit = HIT_NONE;
        ::SetRectEmpty(&m_rcNew);
        Invalidate(TRUE);
    }
 
    return 0;
}

OnLButtonDblClk()

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

protected

Definition at line 338 of file canvas.cpp.

{
    return OnLRButtonDblClk(TRUE, nMsg, wParam, lParam, bHandled);
}

OnLButtonDown()

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

protected

Definition at line 314 of file canvas.cpp.

{
    return OnLRButtonDown(TRUE, nMsg, wParam, lParam, bHandled);
}

OnLButtonUp()

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

protected

Definition at line 608 of file canvas.cpp.

{
    return OnLRButtonUp(TRUE, nMsg, wParam, lParam, bHandled);
}

OnLRButtonDblClk()

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

protected

Definition at line 324 of file canvas.cpp.

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

Referenced by OnLButtonDblClk(), and OnRButtonDblClk().

OnLRButtonDown()

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

protected

Definition at line 252 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
 
    CANVAS_HITTEST hitSelection = SelectionHitTest(pt);
    if (hitSelection != HIT_NONE)
    {
        if (bLeftButton)
        {
            UnZoomed(pt);
            StartSelectionDrag(hitSelection, pt);
        }
        return 0;
    }
 
    CANVAS_HITTEST hit = CanvasHitTest(pt);
    if (hit == HIT_NONE || hit == HIT_BORDER)
    {
        switch (toolsModel.GetActiveTool())
        {
            case TOOL_BEZIER:
            case TOOL_SHAPE:
                toolsModel.OnCancelDraw();
                canvasWindow.Invalidate();
                break;
 
            case TOOL_FREESEL:
            case TOOL_RECTSEL:
                toolsModel.OnFinishDraw();
                canvasWindow.Invalidate();
                break;
 
            default:
                break;
        }
 
        toolsModel.resetTool(); // resets the point-buffer of the polygon and bezier functions
        return 0;
    }
 
    CanvasToImage(pt, TRUE);
 
    if (hit == HIT_INNER)
    {
        m_drawing = TRUE;
        UnZoomed(pt);
        SetCapture();
        toolsModel.OnButtonDown(bLeftButton, pt.x, pt.y, FALSE);
        Invalidate(FALSE);
        return 0;
    }
 
    if (bLeftButton)
    {
        m_whereHit = hit;
        UnZoomed(pt);
        m_ptOrig = pt;
        SetCapture();
    }
    return 0;
}

Referenced by OnLButtonDown(), and OnRButtonDown().

OnLRButtonUp()

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

protected

Definition at line 540 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
    CanvasToImage(pt);
 
    ::ReleaseCapture();
 
    if (m_drawing)
    {
        m_drawing = FALSE;
        toolsModel.OnButtonUp(bLeftButton, pt.x, pt.y);
        Invalidate(FALSE);
        SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) "");
        return 0;
    }
    else if (m_hitSelection != HIT_NONE && bLeftButton)
    {
        EndSelectionDrag(pt);
        return 0;
    }
 
    if (m_whereHit == 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_whereHit)
    {
        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;
    }
    ::SetRectEmpty(&m_rcNew);
 
    imageSaved = FALSE;
 
    m_whereHit = HIT_NONE;
    toolsModel.resetTool(); // resets the point-buffer of the polygon and bezier functions
    Update(NULL);
    Invalidate(TRUE);
    return 0;
}

Referenced by OnLButtonUp(), and OnRButtonUp().

OnMouseMove()

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

protected

Definition at line 348 of file canvas.cpp.

{
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
    CanvasToImage(pt);
 
    if (m_hitSelection != HIT_NONE)
    {
        SelectionDragging(pt);
        return 0;
    }
 
    if (!m_drawing || toolsModel.GetActiveTool() <= TOOL_AIRBRUSH)
    {
        if (toolsModel.GetActiveTool() == TOOL_ZOOM)
        {
            Invalidate(FALSE);
            UpdateWindow();
            CanvasToImage(pt);
            drawZoomFrame(pt.x, pt.y);
        }
 
        TRACKMOUSEEVENT tme = { sizeof(tme) };
        tme.dwFlags = TME_LEAVE;
        tme.hwndTrack = m_hWnd;
        tme.dwHoverTime = 0;
        ::TrackMouseEvent(&tme);
 
        if (!m_drawing)
        {
            CString strCoord;
            strCoord.Format(_T("%ld, %ld"), pt.x, pt.y);
            SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM) (LPCTSTR) strCoord);
        }
    }
 
    if (m_drawing)
    {
        // values displayed in statusbar
        LONG xRel = pt.x - start.x;
        LONG yRel = pt.y - start.y;
 
        switch (toolsModel.GetActiveTool())
        {
            // freesel, rectsel and text tools always show numbers limited to fit into image area
            case TOOL_FREESEL:
            case TOOL_RECTSEL:
            case TOOL_TEXT:
                if (xRel < 0)
                    xRel = (pt.x < 0) ? -start.x : xRel;
                else if (pt.x > imageModel.GetWidth())
                    xRel = imageModel.GetWidth() - start.x;
                if (yRel < 0)
                    yRel = (pt.y < 0) ? -start.y : yRel;
                else if (pt.y > imageModel.GetHeight())
                    yRel = imageModel.GetHeight() - start.y;
                break;
 
            // while drawing, update cursor coordinates only for tools 3, 7, 8, 9, 14
            case TOOL_RUBBER:
            case TOOL_PEN:
            case TOOL_BRUSH:
            case TOOL_AIRBRUSH:
            case TOOL_SHAPE:
            {
                CString strCoord;
                strCoord.Format(_T("%ld, %ld"), pt.x, pt.y);
                SendMessage(hStatusBar, SB_SETTEXT, 1, (LPARAM) (LPCTSTR) strCoord);
                break;
            }
            default:
                break;
        }
 
        // rectsel and shape tools always show non-negative numbers when drawing
        if (toolsModel.GetActiveTool() == TOOL_RECTSEL || toolsModel.GetActiveTool() == TOOL_SHAPE)
        {
            if (xRel < 0)
                xRel = -xRel;
            if (yRel < 0)
                yRel =  -yRel;
        }
 
        if (wParam & MK_LBUTTON)
        {
            toolsModel.OnMouseMove(TRUE, pt.x, pt.y);
            Invalidate(FALSE);
            if ((toolsModel.GetActiveTool() >= TOOL_TEXT) || (toolsModel.GetActiveTool() == TOOL_RECTSEL) || (toolsModel.GetActiveTool() == TOOL_FREESEL))
            {
                CString strSize;
                if ((toolsModel.GetActiveTool() >= TOOL_LINE) && (GetAsyncKeyState(VK_SHIFT) < 0))
                    yRel = xRel;
                strSize.Format(_T("%ld x %ld"), xRel, yRel);
                SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) (LPCTSTR) strSize);
            }
        }
 
        if (wParam & MK_RBUTTON)
        {
            toolsModel.OnMouseMove(FALSE, pt.x, pt.y);
            Invalidate(FALSE);
            if (toolsModel.GetActiveTool() >= TOOL_TEXT)
            {
                CString strSize;
                if ((toolsModel.GetActiveTool() >= TOOL_LINE) && (GetAsyncKeyState(VK_SHIFT) < 0))
                    yRel = xRel;
                strSize.Format(_T("%ld x %ld"), xRel, yRel);
                SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) (LPCTSTR) strSize);
            }
        }
        return 0;
    }
 
    if (m_whereHit == 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_whereHit)
    {
        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
    CString strSize;
    strSize.Format(_T("%d x %d"), cxImage, cyImage);
    SendMessage(hStatusBar, SB_SETTEXT, 2, (LPARAM) (LPCTSTR) strSize);
 
    CRect rc = { 0, 0, cxImage, cyImage };
    switch (m_whereHit)
    {
        case HIT_UPPER_LEFT:
            ::OffsetRect(&rc, cxDelta, cyDelta);
            break;
        case HIT_UPPER_CENTER:
            ::OffsetRect(&rc, 0, cyDelta);
            break;
        case HIT_UPPER_RIGHT:
            ::OffsetRect(&rc, 0, cyDelta);
            break;
        case HIT_MIDDLE_LEFT:
            ::OffsetRect(&rc, cxDelta, 0);
            break;
        case HIT_LOWER_LEFT:
            ::OffsetRect(&rc, cxDelta, 0);
            break;
        default:
            break;
    }
    ImageToCanvas(rc);
    m_rcNew = rc;
    Invalidate(TRUE);
 
    return 0;
}

OnMouseWheel()

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

protected

Definition at line 689 of file canvas.cpp.

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

OnPaint()

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

protected

Definition at line 705 of file canvas.cpp.

{
    RECT rcClient;
    GetClientRect(&rcClient);
 
    PAINTSTRUCT ps;
    HDC hDC = BeginPaint(&ps);
    DoDraw(hDC, rcClient, ps.rcPaint);
    EndPaint(&ps);
    return 0;
}

OnRButtonDblClk()

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

protected

Definition at line 343 of file canvas.cpp.

{
    return OnLRButtonDblClk(FALSE, nMsg, wParam, lParam, bHandled);
}

OnRButtonDown()

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

protected

Definition at line 319 of file canvas.cpp.

{
    return OnLRButtonDown(FALSE, nMsg, wParam, lParam, bHandled);
}

OnRButtonUp()

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

protected

Definition at line 613 of file canvas.cpp.

{
    return OnLRButtonUp(FALSE, nMsg, wParam, lParam, bHandled);
}

OnSetCursor()

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

protected

Definition at line 618 of file canvas.cpp.

{
    POINT pt;
    ::GetCursorPos(&pt);
    ScreenToClient(&pt);
 
    CANVAS_HITTEST hitSelection = SelectionHitTest(pt);
    if (hitSelection != HIT_NONE)
    {
        if (!setCursorOnSizeBox(hitSelection))
            ::SetCursor(::LoadCursor(NULL, IDC_SIZEALL));
        return 0;
    }
 
    CRect rcImage;
    GetImageRect(rcImage);
    ImageToCanvas(rcImage);
    if (::PtInRect(&rcImage, pt))
    {
        switch (toolsModel.GetActiveTool())
        {
            case TOOL_FILL:
                ::SetCursor(::LoadIcon(hProgInstance, MAKEINTRESOURCE(IDC_FILL)));
                break;
            case TOOL_COLOR:
                ::SetCursor(::LoadIcon(hProgInstance, MAKEINTRESOURCE(IDC_COLOR)));
                break;
            case TOOL_ZOOM:
                ::SetCursor(::LoadIcon(hProgInstance, MAKEINTRESOURCE(IDC_ZOOM)));
                break;
            case TOOL_PEN:
                ::SetCursor(::LoadIcon(hProgInstance, MAKEINTRESOURCE(IDC_PEN)));
                break;
            case TOOL_AIRBRUSH:
                ::SetCursor(::LoadIcon(hProgInstance, MAKEINTRESOURCE(IDC_AIRBRUSH)));
                break;
            default:
                ::SetCursor(::LoadCursor(NULL, IDC_CROSS));
        }
        return 0;
    }
 
    if (selectionModel.m_bShow || !setCursorOnSizeBox(CanvasHitTest(pt)))
        ::SetCursor(::LoadCursor(NULL, IDC_ARROW));
 
    return 0;
}

OnSize()

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

protected

Definition at line 202 of file canvas.cpp.

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

OnVScroll()

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

protected

Definition at line 246 of file canvas.cpp.

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

SelectionDragging()

VOID CCanvasWindow::SelectionDragging ( POINT  ptUnZoomed )

protected

Definition at line 757 of file canvas.cpp.

{
    selectionModel.Dragging(m_hitSelection, ptUnZoomed);
    Invalidate(FALSE);
}

Referenced by OnMouseMove().

SelectionHitTest()

CANVAS_HITTEST CCanvasWindow::SelectionHitTest ( POINT  ptZoomed )

protected

Definition at line 734 of file canvas.cpp.

{
    if (!selectionModel.m_bShow)
        return HIT_NONE;
 
    RECT rcSelection = selectionModel.m_rc;
    Zoomed(rcSelection);
    ::OffsetRect(&rcSelection, GRIP_SIZE - GetScrollPos(SB_HORZ), GRIP_SIZE - GetScrollPos(SB_VERT));
    ::InflateRect(&rcSelection, GRIP_SIZE, GRIP_SIZE);
 
    return getSizeBoxHitTest(ptZoomed, &rcSelection);
}

Referenced by OnLRButtonDown(), and OnSetCursor().

StartSelectionDrag()

VOID CCanvasWindow::StartSelectionDrag ( CANVAS_HITTEST  hit, POINT  ptUnZoomed  )

protected

Definition at line 747 of file canvas.cpp.

{
    m_hitSelection = hit;
    selectionModel.m_ptHit = ptUnZoomed;
    selectionModel.TakeOff();
 
    SetCapture();
    Invalidate(FALSE);
}

Referenced by OnLRButtonDown().

Update()

VOID CCanvasWindow::Update

(

HWND

hwndFrom

)

Definition at line 171 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);
}

Member Data Documentation

m_drawing

BOOL CCanvasWindow::m_drawing

Definition at line 38 of file canvas.h.

Referenced by cancelDrawing(), finishDrawing(), CMainWindow::OnCommand(), OnLRButtonDblClk(), OnLRButtonDown(), OnLRButtonUp(), and OnMouseMove().

m_hitSelection

CANVAS_HITTEST CCanvasWindow::m_hitSelection

protected

Definition at line 51 of file canvas.h.

Referenced by cancelDrawing(), EndSelectionDrag(), OnLRButtonUp(), OnMouseMove(), SelectionDragging(), and StartSelectionDrag().

m_ptOrig

POINT CCanvasWindow::m_ptOrig

protected

Definition at line 53 of file canvas.h.

Referenced by OnLRButtonDown(), OnLRButtonUp(), and OnMouseMove().

m_rcNew

CRect CCanvasWindow::m_rcNew

protected

Definition at line 54 of file canvas.h.

Referenced by CCanvasWindow(), DoDraw(), OnCancelMode(), OnKeyDown(), OnLRButtonUp(), and OnMouseMove().

m_whereHit

CANVAS_HITTEST CCanvasWindow::m_whereHit

protected

Definition at line 52 of file canvas.h.

Referenced by DoDraw(), OnCancelMode(), OnKeyDown(), OnLRButtonDown(), OnLRButtonUp(), and OnMouseMove().

---

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

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