In the destructor, you'll first go through the list deleting the element pointed to by each entry. After that is complete, you must delete the pointers from the list. The code to do this is as follows:

CSketcherDoc::~CSketcherDoc(void)
{
  // Delete the element pointed to by each list entry
  for(auto iter = m_ElementList.begin() ; iter != m_ElementList.end() ; ++iter)
    delete *iter;

   m_ElementList.clear();   // Finally delete all pointers
}

You should add this code to the definition of the destructor in SketcherDoc.cpp. You can go directly to the code for the destructor through the Class View.

The for loop iterates over all the elements in the list. The auto keyword ensures the correct type is specified for the iterator iter. When the for loop ends, you call the clear() function for the list to remove all the pointers from the list.

Because the document owns the list of elements and the list is protected, you can't use it directly from the view. The OnDraw() member of the view does need to be able to call the Draw() member for each of the elements in the list, though, so you need to consider how best to arrange this. One possibility is to make some const iterators for the m_ElementList member of the document class available. This will allow the view class object to call the Draw() function for each element, but will prevent the list from being changed. You can add two more functions to the CSketcherDoc class definition to provide for this:

class CSketcherDoc: public CDocument
{

// Rest of the class as before...

// Operations
public:
   unsigned int GetElementType() const // Get the element type
      { return m_Element; }
   COLORREF GetElementColor() const    // Get the element color
      { return m_Color; }
   void AddElement(CElement* pElement) // Add an element to the list
      { m_ElementList.AddTail(pElement); }
   std::list<CElement*>::const_iterator begin() const // Get list begin iterator
                   { return m_ElementList.begin(); }
   std::list<CElement*>::const_iterator end() const   // Get list end iterator
                   { return m_ElementList.end(); }

// Rest of the class as before...

};

The begin() function returns an iterator that points to the first element in the list, and the end() function returns an iterator that points to one past the last element in the list. The iterator type is defined in the list<> class template as const_iterator, but because the iterator type is specific to a particular instance of the template, you must qualify the type name with the list instance type.

By using the two functions you have added to the document class, the OnDraw() function for the view will be able to iterate through the list, calling the Draw() function for each element. This implementation of OnDraw()is as follows:

void CSketcherView::OnDraw(CDC* pDC)
{
   CSketcherDoc* pDoc = GetDocument();
   ASSERT_VALID(pDoc);
   if(!pDoc)
     return;

  CElement* pElement(nullptr);
  for(auto iter = pDoc->begin() ; iter != pDoc->end() ; ++iter)
  {
    pElement = *iter;
    if(pDC->RectVisible(pElement->GetBoundRect())) // If the element is visible
         pElement->Draw(pDC);                      // ...draw it
  }
}
                                                               

Frequently, when a WM_PAINT message is sent to your program, only part of the window needs to be redrawn. When Windows sends the WM_PAINT message to a window, it also defines an area in the client area of the window, and only this area needs to be redrawn. The CDC class provides a member function, RectVisible(), which determines whether a rectangle you supply to it as an argument overlaps the area that Windows requires to be redrawn. Here, you use this function to make sure that you draw only the elements that are in the area Windows wants redrawn, thus improving the performance of the application.

You use the begin() and end() members of the document object in the for loop to iterate over all the elements in the list. The auto keyword determines the type of iter appropriately. Within the loop, you dereference iter and store it in the pElement variable. You retrieve the bounding rectangle for each element using the GetBoundRect() member of the object, and pass it to the RectVisible() function in the if statement. If the value returned by RectVisible() is true, you call the Draw() function for the current element pointed to by pElement. As a result, only elements that overlap the area that Windows has identified as invalid are drawn. Drawing on the screen is a relatively expensive operation in terms of time, so checking for just the elements that need to be redrawn, rather than drawing everything each time, improves performance considerably.

The last thing you need to do to have a working document in our program is to add the code to the OnLButtonUp() handler in the CSketcherView class to add the temporary element to the document:

void CSketcherView::OnLButtonUp(UINT nFlags, CPoint point)
{
   if(this == GetCapture())
      ReleaseCapture();      // Stop capturing mouse messages

   // If there is an element, add it to the document
   if(m_pTempElement)
   {
      GetDocument()->AddElement(m_pTempElement);
      InvalidateRect(nullptr);  // Redraw the current window
      m_pTempElement = nullptr; // Reset the element pointer
   }
}

Of course, you must check that there really is an element before you add it to the document. The user might just have clicked the left mouse button without moving the mouse. After adding the element to the list in the document, you call InvalidateRect() to get the client area for the current view redrawn. The argument of 0 invalidates the whole of the client area in the view. Because of the way the rubber-banding process works, some elements may not be displayed properly if you don't do this. If you draw a horizontal line, for instance, and then rubber-band a rectangle with the same color so that its top or bottom edge overlaps the line, the overlapped bit of line disappears. This is because the edge being drawn is XORed with the line underneath, so you get the background color back. You also reset the pointer m_pTempElement to avoid confusion when another element is created. Note that the statement deleting m_pTempElement has been removed.

After saving all the modified files, you can build the latest version of Sketcher and execute it. You'll now be able to produce art such as "The Happy Programmer," shown in Figure 17-1.

Figure 17.1. FIGURE 17-1

The program is now working more realistically. It stores a pointer to each element in the document object, so they're all automatically redrawn as necessary. The program also does a proper cleanup of the document data when it's deleted.

There are still some limitations in the program that you can address. For instance:

These are all quite serious deficiencies that, together, make the program fairly useless as it stands. You'll overcome all of them before the end of this chapter.

The problem is the coordinate systems you're using — and that plural is deliberate. You've actually been using two coordinate systems in all the examples up to now, although you may not have noticed. As you saw in the previous chapter, when you call a function such as LineTo(), it assumes that the arguments passed are logical coordinates. The function is a member of the CDC class that defines a device context, and the device context has its own system of logical coordinates. The mapping mode, which is a property of the device context, determines what the unit of measurement is for the coordinates when you draw something.

The coordinate data that you receive along with the mouse messages, on the other hand, has nothing to do with the device context or the CDC object — and outside of a device context, logical coordinates don't apply. The points passed to the OnLButtonDown() and OnMouseMove() handlers have coordinates that are always in device units — that is, pixels — and are measured relative to the upper left corner of the client area. These are referred to as client coordinates. Similarly, when you call InvalidateRect(), the rectangle is assumed to be defined in terms of client coordinates.

In MM_TEXT mode, the client coordinates and the logical coordinates in the device context are both in pixels, and so they're the same — as long as you don't scroll the window. In all the previous examples, there was no scrolling, so everything worked without any problems. With the latest version of Sketcher, it all works fine until you scroll the view, whereupon the logical coordinates origin (the 0,0 point) is moved by the scrolling mechanism, so it's no longer in the same place as the client coordinates origin. The units for logical coordinates and client coordinates are the same here, but the origins for the two coordinates systems are different. This situation is illustrated in Figure 17-4.

Figure 17.4. FIGURE 17-4

The left side shows the position in the client area where you draw, and the points that are the mouse positions defining the line. These are recorded in client coordinates. The right side shows where the line is actually drawn. Drawing is in logical coordinates, but you have been using client coordinate values. In the case of the scrolled window, the line appears displaced because the logical origin has been relocated.

This means that you are actually using the wrong values to define elements in the Sketcher program, and when you invalidate areas of the client area to get them redrawn, the rectangles passed to the function are also wrong — hence, the weird behavior of the program. With other mapping modes, it gets worse, because not only are the units of measurement in the two coordinate systems different, but the y axes also may be in opposite directions!

Consider what needs to be done to fix the problem. There are two things you may have to address:

These amount to making sure you always use logical coordinates when using device context functions, and always use client coordinates for other communications about the window. The functions you have to apply to do the conversions are associated with a device context, so you need to obtain a device context whenever you want to convert from logical to client coordinates or vice versa. You can use the coordinate conversion functions of the CDC class inherited by CClientDC to do the work.

The new version of the OnLButtonDown() handler incorporating this is as follows:

// Handler for left mouse button down message
void CSketcherView::OnLButtonDown(UINT nFlags, CPoint point)
{

CClientDC aDC(this);             // Create a device context
   OnPrepareDC(&aDC);               // Get origin adjusted
   aDC.DPtoLP(&point);              // Convert point to logical coordinates
   m_FirstPoint = point;            // Record the cursor position
   SetCapture();                    // Capture subsequent mouse messages
}

You obtain a device context for the current view by creating a CClientDC object and passing the pointer this to the constructor. The advantage of CClientDC is that it automatically releases the device context when the object goes out of scope. It's important that device contexts are not retained, as there are a limited number available from Windows and you could run out of them. If you use CClientDC, you're always safe.

As you're using CScrollView, the OnPrepareDC() member function inherited from that class must be called to set the origin for the logical coordinate system in the device context to correspond with the scrolled position. After you have set the origin by this call, you use the function DPtoLP(), which converts from Device Points to Logical Points, to convert the point value that's passed to the handler to logical coordinates. You then store the converted point, ready for creating an element in the OnMouseMove() handler.

The new code for the OnMouseMove() handler is as follows:

void CSketcherView::OnMouseMove(UINT nFlags, CPoint point)
{
   CClientDC aDC(this);             // Device context for the current view
   OnPrepareDC(&aDC);               // Get origin adjusted
   aDC.DPtoLP(&point);              // Convert point to logical coordinates
   if((nFlags&MK_LBUTTON)&&(this==GetCapture()))
   {
      m_SecondPoint = point;        // Save the current cursor position

   // Rest of the function as before...
}

The code for the conversion of the point value passed to the handler is essentially the same as in the previous handler, and that's all you need here for the moment. The last function that you must change is easy to overlook: the OnUpdate() function in the view class. This needs to be modified to the following:

void CSketcherView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
{
   // Invalidate the area corresponding to the element pointed to
   // if there is one, otherwise invalidate the whole client area
   if(pHint)
   {
      CClientDC aDC(this);            // Create a device context
      OnPrepareDC(&aDC);              // Get origin adjusted

      // Get the enclosing rectangle and convert to client coordinates
      CRect aRect = static_cast<CElement*>(pHint)->GetBoundRect();
      aDC.LPtoDP(aRect);
      InvalidateRect(aRect);          // Get the area redrawn
   }

else
  {
    InvalidateRect(nullptr);          // Invalidate the client area
  }
}

The modification here creates a CClientDC object and uses the LPtoDP() function member to convert the rectangle for the area that's to be redrawn to client coordinates.

If you now compile and execute Sketcher with the modifications I have discussed and are lucky enough not to have introduced any typos, it will work correctly, regardless of the scroller position.

We will create a very simple mechanism for selecting an element. An element in a sketch will be selected whenever the mouse cursor is within the bounding rectangle for an element. For this to be effective, Sketcher must track at all times, whether or not there is an element under the cursor.

To keep track of which element is under the cursor, you can add code to the OnMouseMove() handler in the CSketcherView class. This handler is called every time the mouse cursor moves, so all you have to do is add code to determine whether there's an element under the current cursor position and set m_pSelected accordingly. The test for whether a particular element is under the cursor is simple: if the cursor position is within the bounding rectangle for an element, that element is under the cursor. Here's how you can modify the OnMouseMove() handler to determine whether there's an element under the cursor:

void CSketcherView::OnMouseMove(UINT nFlags, CPoint point)
{
  // Define a Device Context object for the view
  CClientDC aDC(this);              // DC is for this view
  OnPrepareDC(&aDC);                // Get origin adjusted
  aDC.DPtoLP(&point);               // Convert point to logical coordinates
  if((nFlags & MK_LBUTTON) && (this == GetCapture()))
  {
    // Code as before...
  }

else
  {  // We are not creating an element, so select an element
    CSketcherDoc* pDoc=GetDocument();         // Get a pointer to the document
    m_pSelected = pDoc->FindElement(point);   // Set selected element
  }
}

The new code is very simple and is executed only when we are not creating a new element. The else clause in the if statement calls the FindElement() function for the document object that you'll add shortly and stores the element address that is returned in m_pSelected. The FindElement() function has to search the document for the first element that has a bounding rectangle that encloses point. You can add FindElement() to the document class as a public member and implement it like this:

// Finds the element under the point
CElement* CSketcherDoc::FindElement(const CPoint& point)const
{
  for(auto rIter = m_ElementList.rbegin() ; rIter != m_ElementList.rend() ; ++rIter)
  {
    if((*rIter)->GetBoundRect().PtInRect(point))
      return *rIter;
  }
  return nullptr;
}

You use a reverse-iterator to search the list from the end, which means the most recently created and, therefore, last-drawn element will be found first. The PtInRect() member of the CRect class returns TRUE if the point you pass as the argument lies within the rectangle, and FALSE otherwise. Here, you use this function to test whether or not the point lies within any bounding rectangle for an element in the sketch. The address of the first element for which this is true is returned. If no element in the sketch is found, the loop will end and nullptr will be returned. The code is now in a state where you can test the context menus.

You still need to arrange that the highlighted element is actually drawn highlighted. Somewhere, the m_pSelected pointer must be passed to the draw function for each element. The only place to do this is in the OnDraw() function in the view:

void CSketcherView::OnDraw(CDC* pDC)
{
  CSketcherDoc* pDoc = GetDocument();
  ASSERT_VALID(pDoc);
  if (!pDoc)
    return;

  CElement* pElement(nullptr);
  for(auto iter = pDoc->begin() ; iter != pDoc->end() ; ++iter)
  {
    pElement = *iter;
    if(pDC->RectVisible(pElement->GetBoundRect())) // If the element is visible
         pElement->Draw(pDC, m_pSelected);         // ...draw it
  }
}

You need to change only one line. The Draw() function for an element has the second argument added to communicate the address of the element to be highlighted.

This is all that's required for the highlighting to work all the time. It wasn't trivial but, on the other hand, it wasn't terribly difficult. You can build and execute Sketcher to try it out. Any time there is an element under the cursor, the element is drawn in magenta. This makes it obvious which element the context menu is going to act on before you right-click the mouse, and means that you know in advance which context menu will be displayed.

The code that you need in the OnElementDelete() handler in the CSketcherView class to delete the currently selected element is simple:

void CSketcherView::OnElementDelete()
{
  if(m_pSelected)
  {
    CSketcherDoc* pDoc = GetDocument();// Get the document pointer
    pDoc->DeleteElement(m_pSelected);  // Delete the element
    pDoc->UpdateAllViews(nullptr);     // Redraw all the views
    m_pSelected = nullptr;             // Reset selected element ptr
  }
}

The code to delete an element is executed only if m_pSelected contains a valid address, indicating that there is an element to be deleted. You get a pointer to the document and call the function DeleteElement() for the document object; you'll add this member to the CSketcherDoc class in a moment. When the element has been removed from the document, you call UpdateAllViews() to get all the views redrawn without the deleted element. Finally, you set m_pSelected to nullptr to indicate that there isn't an element selected.

You can add a declaration for DeleteElement() as a public member of the CSketcherDoc class:

class CSketcherDoc : public CDocument
{
protected: // create from serialization only
       CSketcherDoc();
       DECLARE_DYNCREATE(CSketcherDoc)

// Attributes
public:

// Operations
public:
      unsigned int GetElementType() const      // Get the element type
         { return m_Element; }
      COLORREF GetElementColor() const         // Get the element color
         { return m_Color; }
   void AddElement(CElement* pElement)         // Add an element to the list
      { m_ElementList.push_back(pElement); }
   std::list<CElement*>::const_iterator begin() const
     { return m_ElementList.begin(); }
   std::list<CElement*>::const_iterator end() const
     { return m_ElementList.end(); }
  CElement* FindElement(const CPoint& point) const;

   void DeleteElement(CElement* pElement);     // Delete an element

// Rest of the class as before...
};

It accepts as an argument a pointer to the element to be deleted and returns nothing. You can implement it in SketcherDoc.cpp as the following:

// Delete an element from the sketch
void CSketcherDoc::DeleteElement(CElement* pElement)
{
  if(pElement)
  {
    m_ElementList.remove(pElement);    // Remove the pointer from the list
    delete pElement;                   // Delete the element from the heap
  }
}

You shouldn't have any trouble understanding how this works. You use pElement with the remove() member of the list<CElement*> object to delete the pointer from the list, then you delete the element pointed to by the parameter pElement from the heap.

That's all you need in order to delete elements. You should now have a Sketcher program in which you can draw in multiple scrolled views, and delete any of the elements in your sketch from any of the views.

Moving the selected element is a bit more involved. As the element must move along with the mouse cursor, you must add code to the OnMouseMove() method to provide for this behavior. As this function is also used to draw elements, you need a mechanism for indicating when you're in "move" mode. The easiest way to do this is to have a flag in the view class, which you can call m_MoveMode. If you make it of type BOOL, the Windows API Boolean type, you use the value TRUE for when move mode is on, and FALSE for when it's off. Of course, you can also define it as the C++ fundamental type, bool, with the values true and false.

You'll also have to keep track of the cursor during the move, so you can add another data member in the view for this. You can call it m_CursorPos, and it will be of type CPoint. Another thing you should provide for is the possibility of aborting a move. To do this, you must remember the first position of the cursor when the move operation started, so you can move the element back when necessary. This is another member of type CPoint, and it is called m_FirstPos. Add the three new members to the protected section of the view class:

class CSketcherView: public CScrollView
{
  // Rest of the class as before...

  protected:
    CPoint m_FirstPoint;       // First point recorded for an element
    CPoint m_SecondPoint;      // Second point recorded for an element
    CElement* m_pTempElement;  // Pointer to temporary element
    CElement* m_pSelected;     // Currently selected element
    bool m_MoveMode;           // Move element flag
    CPoint m_CursorPos;        // Cursor position
    CPoint m_FirstPos;         // Original position in a move

   // Rest of the class as before...
};

These must also be initialized in the constructor for CSketcherView, so modify it to the following:

CSketcherView::CSketcherView()
: m_FirstPoint(CPoint(0,0))
, m_SecondPoint(CPoint(0,0))
, m_pTempElement(nullptr)
, m_pSelected(nullptr)
, m_MoveMode(false)
, m_CursorPos(CPoint(0,0))
, m_FirstPos(CPoint(0,0))
{
  // TODO: add construction code here
}

The element move process starts when the Move menu item from the context menu is selected. Now, you can add the code to the message handler for the Move menu item to set up the conditions necessary for the operation:

void CSketcherView::OnElementMove()
{
   CClientDC aDC(this);
   OnPrepareDC(&aDC);              // Set up the device context
   GetCursorPos(&m_CursorPos);     // Get cursor position in screen coords
   ScreenToClient(&m_CursorPos);   // Convert to client coords
   aDC.DPtoLP(&m_CursorPos);       // Convert to logical
   m_FirstPos = m_CursorPos;       // Remember first position
   m_MoveMode = true;              // Start move mode
}

You are doing four things in this handler:

The GetCursorPos() function is a Windows API function that stores the current cursor position in m_CursorPos. Note that you pass a reference to this function. The cursor position is in screen coordinates (that is, coordinates measured in pixels relative to the upper-left corner of the screen). All operations with the cursor are in screen coordinates. You want the position in logical coordinates, so you must do the conversion in two steps. The ScreenToClient() function (which is an inherited member of the view class) converts from screen to client coordinates, and then you apply the DPtoLP() function member of the aDC object to the result to convert to logical coordinates.

After saving the initial cursor position in m_FirstPos, you set m_MoveMode to true so that the OnMouseMove() handler can deal with moving the element.

Now that you have set the move mode flag, it's time to update the mouse move message handler to deal with moving an element.

Moving an element only occurs when move mode is on and the cursor is being moved. Therefore, all you need to do in OnMouseMove() is add code to handle moving an element in a block that gets executed only when m_MoveMode is TRUE. The new code to do this is as follows:

void CSketcherView::OnMouseMove(UINT nFlags, CPoint point)
{
  CClientDC aDC(this);              // DC is for this view
  OnPrepareDC(&aDC);                // Get origin adjusted

  aDC.DPtoLP(&point);               // Convert point to logical coordinates

// If we are in move mode, move the selected element and return
  if(m_MoveMode)
  {
    MoveElement(aDC, point);        // Move the element
    return;
  }

   // Rest of the mouse move handler as before...
}

This addition doesn't need much explaining, really, does it? The if statement verifies that you're in move mode and then calls a function MoveElement(), which does what is necessary for the move. All you have to do now is implement this function.

Add the declaration for MoveElement() as a protected member of the CSketcherView class by adding the following at the appropriate point in the class definition:

void MoveElement(CClientDC& aDC, const CPoint& point); // Move an element

As always, you can also right-click the class name in Class View to do this, if you want to. The function needs access to the object encapsulating a device context for the view, aDC, and the current cursor position, point, so both of these are reference parameters. The implementation of the function in the SketcherView.cpp file is as follows:

void CSketcherView::MoveElement(CClientDC& aDC, const CPoint& point)
{
  CSize distance = point - m_CursorPos;   // Get move distance
  m_CursorPos = point;                    // Set current point as 1st for
                                          // next time

  // If there is an element selected, move it
  if(m_pSelected)
  {
    aDC.SetROP2(R2_NOTXORPEN);
    m_pSelected->Draw(&aDC, m_pSelected); // Draw the element to erase it
    m_pSelected->Move(distance);          // Now move the element
    m_pSelected->Draw(&aDC, m_pSelected); // Draw the moved element
  }
}

The distance to move the element that is currently selected is stored locally as a CSize object, distance. The CSize class is specifically designed to represent a relative coordinate position and has two public data members, cx and cy, which correspond to the x and y increments. These are calculated as the difference between the current cursor position, stored in point, and the previous cursor position, saved in m_CursorPos. This uses the subtraction operator, which is overloaded in the CPoint class. The version you are using here returns a CSize object, but there is also a version that returns a CPoint object. You can usually operate on CSize and CPoint objects combined. You save the current cursor position in m_CursorPos for use the next time this function is called, which occurs if there is a further mouse move message during the current move operation.

You implement moving an element in the view using the R2_NOTXORPEN drawing mode, because it's easy and fast. This is exactly the same as what you have been using during the creation of an element. You redraw the selected element in its current color (the selected color) to reset it to the background color, and then call the function Move() to relocate the element by the distance specified by distance. You'll add this function to the element classes in a moment. When the element has moved itself, you simply use the Draw() function once more to display it highlighted at the new position. The color of the element will revert to normal when the move operation ends, as the OnLButtonUp() handler will redraw all the windows normally by calling UpdateAllViews().

Add the Move() function as a virtual member of the base class, CElement. Modify the class definition to the following:

class CElement : public CObject
{
   protected:
     int m_PenWidth;                   // Pen width
     COLORREF m_Color;                 // Color of an element
     CRect m_EnclosingRect;            // Rectangle enclosing an element
   public:
     virtual ~CElement();

     // Virtual draw operation
     virtual void Draw(CDC* pDC, CElement* pElement=nullptr) {}
     virtual void Move(const CSize& aSize){} // Move an element

     CRect GetBoundRect();             // Get the bounding rectangle for an element

   protected:
     CElement();                       // Here to prevent it being called
};

As discussed earlier in relation to the Draw() member, although an implementation of the Move() function here has no meaning, you can't make it a pure virtual function because of the requirements of serialization.

You can now add a declaration for the Move() function as a public member of each of the classes derived from CElement. It is the same in each:

virtual void Move(const CSize& aSize); // Function to move an element

Next, you can add the implementation of the Move() function in the CLine class to Elements.cpp:

void CLine::Move(const CSize& aSize)
{
  m_StartPoint += aSize;               // Move the start point
  m_EndPoint += aSize;                 // and the end point
  m_EnclosingRect += aSize;            // Move the enclosing rectangle
}

This is easy because of the overloaded += operators in the CPoint and CRect classes. They all work with CSize objects, so you just add the relative distance specified by aSize to the start and end points for the line and to the enclosing rectangle.

Moving a CRectangle object is even easier:

void CRectangle::Move(const CSize& aSize)
{
  m_EnclosingRect+= aSize;             // Move the rectangle
}

Because the rectangle is defined by the m_EnclosingRect member, that's all you need to move it.

The Move() member of the CCircle class is identical:

void CCircle::Move(const CSize& aSize)
{
  m_EnclosingRect+= aSize;             // Move rectangle defining the circle
}

Moving a CCurve object is a little more complicated, because it's defined by an arbitrary number of points. You can implement the function as follows:

void CCurve::Move(const CSize& aSize)
{
  m_EnclosingRect += aSize;            // Move the rectangle
  // Now move all the points
  std::for_each(m_Points.begin(), m_Points.end(),
                                 [&aSize](CPoint& p){ p += aSize; });
}

So that you don't forget about them, I have used an algorithm and a lambda expression here. You will need to add an #include directive for the algorithm header to Elements.cpp.

There's still not a lot to it. You first move the enclosing rectangle stored in m_EnclosingRect, using the overloaded += operator for CRect objects. You then use the STL for_each algorithm to apply the lambda expression that is the third argument to all the points defining the curve. The capture clause for the lambda expression accesses the aSize parameter by reference. Of course, the lambda parameter must be a reference so the original points can be updated.

Once you have clicked on the Move menu item, the element under the cursor will move around as you move the mouse. All that remains now is to add the capability to drop the element in position once the user has finished moving it, or to abort the whole move. To drop the element in its new position, the user clicks the left mouse button, so you can manage this operation in the OnLButtonDown() handler. To abort the operation, the user clicks the right mouse button — so you can add the code to the OnRButtonDown() handler to deal with this.

You can take care of the left mouse button first. You'll have to provide for this as a special action when move mode is on. The changes are highlighted in the following:

void CSketcherView::OnLButtonDown(UINT nFlags, CPoint point)
{
  CClientDC aDC(this);                 // Create a device context
  OnPrepareDC(&aDC);                   // Get origin adjusted

aDC.DPtoLP(&point);                  // convert point to Logical

  if(m_MoveMode)
  {
    // In moving mode, so drop the element
    m_MoveMode = false;                // Kill move mode
    m_pSelected = nullptr;             // De-select the element
    GetDocument()->UpdateAllViews(0);  // Redraw all the views
    return;
  }
    m_FirstPoint = point;              // Record the cursor position
    SetCapture();                      // Capture subsequent mouse messages
}

The code is pretty simple. You first make sure that you're in move mode. If this is the case, you just set the move mode flag back to false and then de-select the element. This is all that's required because you've been tracking the element with the mouse, so it's already in the right place. Finally, to tidy up all the views of the document, you call the document's UpdateAllViews() function, causing all the views to be redrawn.

Add a handler for the WM_RBUTTONDOWN message to CSketcherView using the Properties window for the class. The implementation for aborting a move must do two things. It must move the element back to where it was and turn off move mode. You can move the element back in the right-button-down handler, but you must leave switching off move mode to the right-button-up handler to allow the context menu to be suppressed. The code to move the element back is as follows:

void CSketcherView::OnRButtonDown(UINT nFlags, CPoint point)
{
   if(m_MoveMode)
   {
     // In moving mode, so drop element back in original position
     CClientDC aDC(this);
     OnPrepareDC(&aDC);                      // Get origin adjusted
     MoveElement(aDC, m_FirstPos);           // Move element to original position
     m_pSelected = nullptr;                  // De-select element
     GetDocument()->UpdateAllViews(nullptr); // Redraw all the views
  }
}

You first create a CClientDC object for use in the MoveElement() function. You then call the MoveElement() function to move the currently selected element the distance from the current cursor position to the original cursor position that we saved in m_FirstPos. After the element has been repositioned, you just deselect the element and get all the views redrawn.

The last thing you must do is switch off move mode in the button-up handler:

void CSketcherView::OnRButtonUp(UINT /* nFlags */, CPoint point)
{
  if(m_MoveMode)
  {
    m_MoveMode = false;
    return;
  }

ClientToScreen(&point);
  OnContextMenu(this, point);
}

Now, the context menu gets displayed only when move mode is not in progress.

Everything is now complete for the context pop-ups to work. If you build Sketcher, you can select the element type and color from one context menu, or if you are over an element, you can move that element or delete it from the other context menu.

To highlight an element, you must discover which element, if any, is under the cursor at any given time. It would be helpful if an element could tell you if a given point is within the bounding rectangle. This process will be the same for all types of element, so you can add a public function to the Element base class to implement this:

bool Hit(Point p)
 {
  return boundRect.Contains(p);
  }

The Contains() member of the System::Drawing::Rectangle structure returns true if the Point argument lies within the rectangle, and false otherwise. There are two other versions of this function: one accepts two arguments of type int that specify the x and y coordinates of a point, and the other accepts an argument of type System::Drawing::Rectangle and returns true if the rectangle for which the function is called contains the rectangle passed as an argument.

You can now add a public function to the Sketch class to determine if any element in the sketch is under the cursor:

Element^ HitElement(Point p)
{
      for (auto riter = elements->rbegin(); riter != elements->rend(); ++riter)
      {
        if((*riter)->Hit(p))
          return *riter;
      }
  return nullptr;
}

This function iterates over the elements in the sketch in reverse order, starting with the last one added to the container, and returns a reference to the first element for which the Hit() function returns true. If the Hit() function does not return true for any of the elements in the sketch, the HitElement() function returns nullptr. This provides a simple way to detect whether or not there is an element under the cursor.

Add a private member, highlightedElement, of type Element^ to the Form1 class to record the currently highlighted element and initialize it to nullptr in the Form1 constructor. Because there's such a lot of code in the Form1 class, it is best to do this by right-clicking the class name and selecting Add

private: System::Void Form1_MouseMove(System::Object^  sender,
   System::Windows::Forms::MouseEventArgs^  e)
{
  if(drawing)
  {
    if(tempElement)
       Invalidate(tempElement->bound);        // Invalidate old element area
    switch(elementType)
    {
      case ElementType::LINE:

        tempElement = gcnew Line(color, firstPoint, e->Location);
        break;
      case ElementType::RECTANGLE:

tempElement = gcnew Rectangle(color, firstPoint, e->Location);
        break;
      case ElementType::CIRCLE:
        tempElement = gcnew Circle(color, firstPoint, e->Location);
        break;
      case ElementType::CURVE:
        if(tempElement)
          safe_cast<Curve^>(tempElement)->Add(e->Location);
        else
          tempElement = gcnew Curve(color, firstPoint, e->Location);
        break;
    }
    Invalidate(tempElement->bound);           // Invalidate new element area
    Update();                                 // Repaint
  }
  else
  {
    // Find the element under the cursor - if any
    Element^ element(sketch->HitElement(e->Location));
    if(highlightedElement == element)         // If the old is same as the new
      return;                                 // there's nothing to do

    // Reset any existing highlighted element
    if(highlightedElement)
    {
      Invalidate(highlightedElement->bound);  // Invalidate element area
      highlightedElement->highlighted = false;
      highlightedElement = nullptr;
    }
    // Find and set new highlighted element, if any
    highlightedElement = element;
    if(highlightedElement)
    {
      highlightedElement->highlighted = true;
      Invalidate(highlightedElement->bound);  // Invalidate element area
    }
    Update();                                 // Send a paint message
  }
}

There's a change to the original code that is executed to improve performance when drawing is true. The old code redraws the entire sketch to highlight an element when, in fact, only the regions occupied by the un-highlighted element and the newly highlighted element need to be redrawn. The Invalidate() member of the System::Windows::Forms::Form class has an overloaded version that accepts an argument of type System::Drawing::Rectangle to add the rectangle specified by the argument to the currently invalidated region for the form. Thus, you can call Invalidate() repeatedly to accumulate a composite of rectangles to be redrawn.

Calling Invalidate() with a rectangle argument does not redraw the form, but you can get the invalid region redrawn by calling the Update() function for the form. You must pass the enclosing rectangle for an element to Invalidate(), rather than the bounding rectangle, to get elements redrawn properly, because the shapes extend beyond the right and bottom edges of the bounding rectangle by the thickness of the pen. You will therefore have to adjust the existing bounding rectangles to take the pen width into account if this is to work properly; you'll get to that in a moment.

You now pass the bounding rectangle of the old temporary element to the Invalidate() function to get just that area added to the region to be repainted. When you have created a new temporary element, you add its bounding rectangle to the region to be repainted. You finally call Update() for the Form1 object to send a WM_Paint message. The effect of all this is that only the region occupied by the old and new temporary elements will be repainted, so the operation will be much faster than drawing the whole of the client area.

If drawing is false, you execute the highlighting code in the else clause. First, you get a reference to a new element under the cursor by calling the HitElement() function for the sketch. If the return value is the same as highlightedElement, either they are both nullptr or both reference the same element — either way, there's nothing further to be done.

If you don't return from the handler, you test for an existing highlighted element, and if there is one, you invalidate the rectangle it occupies and reset it by setting the value of its highlighted property to false. You then set highlightedElement back to nullptr. You store the element value in highlightedElement, and if this is not null, you set the highlighted member for the element to true and call Invalidate() with the bounding rectangle as the argument. Finally, you call Update() to redraw the invalid region.

The highlight code will execute repeatedly for every movement of the mouse cursor, so it needs to be efficient.

The overloaded -= operator in the Sketch class already provides you with a way to delete an element. You can use the operator-=() function in the implementation of the Click event handler for the Delete menu item:

private: System::Void deleteContextMenuItem_Click(System::Object^  sender,
                                                  System::EventArgs^  e)
{
  if(highlightedElement)
  {
    sketch -= highlightedElement;              // Delete the highlighted element
    Invalidate(highlightedElement->bound);
    highlightedElement = nullptr;
    Update();
  }
}

As well as deleting the element from the sketch, the event handler also invalidates the region it occupies to remove it from the display, and resets highlightedElement back to nullptr.

The Send to Back operation works much as in MFC Sketcher. You remove the highlighted element from the list in the Sketch object and add it to the end of the list. Here's the implementation of the handler function:

private: System::Void sendToBackContextMenuItem_Click(System::Object^  sender,
                                                             System::EventArgs^  e)
{
  if(highlightedElement)
  {
    sketch -= highlightedElement;              // Delete the highlighted
                                               // element
    sketch->push_front(highlightedElement);    // Then add it back to the
                                               // beginning
    highlightedElement->highlighted = false;
    Invalidate(highlightedElement->bound);
    highlightedElement = nullptr;
    Update();
  }
}

You delete the highlighted element using the operator-=() function, and then add it back to the beginning of the list using the push_front() function that you will define in the Sketch class in a moment. You reset the highlighted member of the element to false and highlightedElement to nullptr before calling Invalidate() for the form to redraw the region occupied by the previously highlighted element.

You can implement push_front() as a public function in the Sketch class definition as follows:

void push_front(Element^ element)
{
  elements->push_front(element);
}

You'll move an element by dragging it with the left mouse button down. This implies that a move operation needs a different set of functions from normal to be carried out by the mouse event handlers, so a move will have to be modal, as in the MFC version of Sketcher. You can identify possible modes with an enum class that you can add following the ElementType enum in Form1.h:

enum class Mode {Normal, Move};

This defines just two modes, but you could add more if you wanted to implement other modal operations. You can now add a private member of type Mode with the name mode to the Form1 class. Initialize the new variable to Mode::Normal in the Form1 constructor.

The only thing the Click event handler for the Move menu item has to do is set mode to Mode::Move:

private: System::Void moveContextMenuItem_Click(System::Object^  sender,

System::EventArgs^  e)
{
  mode = Mode::Move;
}

The mouse event handlers for the form must take care of moving an element. Change the code for the MouseDown handler so it sets drawing to true only when mode is Mode::Normal:

private: System::Void Form1_MouseDown(System::Object^  sender,

System::Windows::Forms::MouseEventArgs^  e)
{
  if(e->Button == System::Windows::Forms::MouseButtons::Left)
  {
    if(mode == Mode::Normal)
    {
      drawing = true;
    }
    firstPoint = e->Location;
  }
}

This sets drawing to true only when mode has the value Mode::Normal. If mode has a different value, only the point is stored for use in the MouseMove event handler. The MouseMove event handler will not create elements when drawing is false, so this functionality is switched off for all modes except Mode::Normal. The MouseUp event handler will restore mode to Mode::Normal when a move operation is complete.

Because you now draw all elements relative to a given position, you can move an element just by changing the inherited position member to reflect the new position and to adjust the location of the bounding rectangle in a similar way. You can add a public Move() function to the Element base class to take care of this:

void Move(int dx, int dy)
{
  position.Offset(dx, dy);
  boundRect.X += dx;
  boundRect.Y += dy;
}

Calling the Offset() function for the Point object, position, adds dx and dy to the coordinates stored in the object. To adjust the location of boundRect, just add dx to the Rectangle object's X field and dy to its Y field.

The MouseMove event handler will expedite the moving process:

private: System::Void Form1_MouseMove(System::Object^  sender,
 System::Windows::Forms::MouseEventArgs^  e) {
   if(drawing)
  {
    if(tempElement)
      Invalidate(tempElement->Bound);  // The old element region
    switch(elementType)
    {
       // Code to create a temporary element as before...
    }
    Invalidate(tempElement->bound);    // The new element region
    Update();
   }
     else if(mode == Mode::Normal)
   {
       // Code to highlight the element under the cursor as before
    }
   else if(mode == Mode::Move &&
                         e->Button ==
 System::Windows::Forms::MouseButtons::Left)
   {  // Move the highlighted element
     if(highlightedElement)
     {
        Invalidate(highlightedElement->bound);     // Region before move
        highlightedElement->Move(e->X - firstPoint.X, e->Y - firstPoint.Y);
        firstPoint = e->Location;
        Invalidate(highlightedElement->bound);     // Region after move
        Update();
     }
   }
}

This event handler now provides three different functions: it creates an element when drawing is true, it does element highlighting when drawing is false and mode is Mode::Normal, and it moves the currently highlighted element when mode is Mode::Move and the left mouse button is down. This means that moving an element in this version of Sketcher will work a little differently from in the native version. To move an element, you select Move from the context menu, then drag the element to its new position with the left button down.

The new else if clause executes only when mode has the value Mode::Move and the left button is down. Without the button test, moving would occur if you moved the cursor after clicking the menu item. This would happen without a MouseDown event occurring, which would create some confusion, as firstPoint would not have been initialized. With the code as you have it here, the moving process is initiated when you click the menu item and release the left mouse button. You then press the left mouse button and drag the cursor to move the highlighted element.

If there is a highlighted element, you invalidate its bounding rectangle before moving the element the distance from firstPoint to the current cursor location. You then update firstPoint to the current cursor position, ready for the next move increment, and invalidate the new region the highlighted element occupies. You finally call Update() to redraw the invalid regions of the form.

The last part you must implement to complete the ability to move elements is in the MouseUp event handler:

private: System::Void Form1_MouseUp(System::Object^  sender,
 System::Windows::Forms::MouseEventArgs^  e)
{
  if(!drawing)
  {
    mode = Mode::Normal;
    return;
  }
  if(tempElement)
  {
    sketch += tempElement;
    tempElement = nullptr;
    Invalidate();
  }
  drawing = false;
}

Releasing the left mouse button ends a move operation. The drawing variable is false when an element is being moved, and the only thing the handler has to do when this is the case is reset mode to Mode::Normal to end the move operation.

With that done, you should now have a version of CLR Sketcher in which you can move and delete elements, as illustrated in Figure 17-8.

Figure 17.8. FIGURE 17-8

The Send to Back facility ensures that any element can always be highlighted to be moved or deleted; if an element will not highlight, just Send to Back any elements enclosing the element you want to move or delete. In Chapter 19, you will implement the capability to save a sketch in a file.