Updating Multiple Views

The document class contains the UpdateAllViews() function to help with this particular problem. The function provides a means for the document to send a message to all its views. You just need to call it from the AddElement() function in CSketcherDoc that adds a new element:

  void AddElement(std::shared_ptr<CElement>& pElement)
  {
    m_Sketch.push_back(pElement);
    UpdateAllViews(nullptr, 0, pElement.get());       // Tell all the views
  }

The inherited UpdateAllViews() function is called whenever an element is added to the document. This communicates with the views by calling the OnUpdate() member of each view. The UpdateAllViews() function has three parameters, two of which have default values. The arguments that you can supply are:

1. A pointer to the current view object. This identifies the view for which the OnUpdate() function should not be called. This is a useful feature when the current view is up to date and you have a pointer to it. You could arrange for this if you needed to by adding an extra parameter of type CSketcherView* to AddElement() and passing the this pointer for the view to it when it was called. Another possibility is that you could call UpdateAllViews() from a view object when an element is created. When you specify nullptr as the argument as in this instance, OnUpdate() will be called for all views. This will be passed on as the first argument in all OnUpdate() function calls.
2. A long integer value that has a default value of zero. This is intended to provide a hint about the region to be updated. If you supply a value for this, it will be passed as the second argument in the call to the OnUpdate() function for each view object.
3. A pointer of type CObject* with a default value of nullptr. If you supply this argument, it will be passed as the third argument in the OnUpdate() function call for each view. It should point to an object that provides information about the region to be updated. In our case it should be a pointer to the new element; a smart pointer cannot be used. Calling get() for the smart pointer, pElement, returns the CElement* pointer that pElement contains.

To process the information passed to the UpdateAllViews() function, you must add an override for the OnUpdate() member of the view class. You can do this through the Properties window for CSketcherView. Just to remind you, you display the properties for a class by right-clicking the class name in Class View and selecting Properties from the menu. If you click the Overrides button in the Properties window, you’ll be able to find OnUpdate in the list of functions. Click the function name, then the <Add> OnUpdate option that shows in the drop-down list in the adjacent column. You’ll be able to edit the code for the OnUpdate() override you have added in the Editor pane. You only need to add the following highlighted code to the function definition:

void CSketcherView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
{
   // Invalidate the area corresponding to the element pointed to
   // by the third argument, otherwise invalidate the whole client area
   if(pHint)
   {
      InvalidateRect(dynamic_cast<CElement*>(pHint)->GetEnclosingRect());
   }
   else
   {
      InvalidateRect(nullptr);
   }
}

Note that you must uncomment the parameter names; otherwise, it won’t compile with the additional code. The three arguments passed to OnUpdate() correspond to the arguments that you passed in the UpdateAllViews() function call. Thus, pHint contains the address of the new element. However, you can’t assume that this is always the case. The OnUpdate() function is also called when a view is first created, but with nullptr for the third argument. Therefore, the function verifies that pHint isn’t nullptr and only then calls GetEnclosingRect() to obtain the rectangle enclosing the element. It invalidates this area in the client area of the view by passing the rectangle to the InvalidateRect() function. This area is redrawn by the OnDraw() function in this view when the next WM_PAINT message is sent to the view. If pHint is nullptr, the whole client area is invalidated.

You might be tempted to consider redrawing the new element in the OnUpdate() function. This isn’t a good idea. You should do permanent drawing only in response to a Windows WM_PAINT message. This means that the OnDraw() function in the view should be the only thing that’s initiating any drawing operations for document data. This ensures that the view is drawn correctly whenever Windows deems it necessary.

Come to think of it, the views ought to be notified when an element is deleted from the document. You can modify the DeleteElement() member of the document class to take care of it:

  void DeleteElement(std::shared_ptr<CElement>& pElement)
  {
    m_Sketch.remove(pElement);
    UpdateAllViews(nullptr, 0, pElement.get());    // Tell all the views
  }

Calling remove() for the list removes the element that matches the argument by calling its destructor. This will cause the smart pointer that was in the list to be destroyed. The element to which it points will not be destroyed because there is another shared_ptr referencing it, namely the object that was passed to DeleteElement(). You use this to pass the element pointer to UpdateAllViews(). The smart pointer is passed by reference, so the element will ultimately be destroyed when the smart pointer on the calling site is destroyed.

If you build and execute Sketcher with the new modifications, you should find that you can create multiple views of the document and draw in any of them. All the views get updated to reflect the contents of the document.

Scrolling Views

Adding scrolling to a view looks remarkably easy at first sight, but the water is, in fact, deeper and murkier than it at first appears. We will jump in anyway. The first step is to change the base class for CSketcherView from CView to CScrollView. This new base class has the scrolling functionality built in, so you can alter the definition of the CSketcherView class to this:

class CSketcherView : public CScrollView
{
   // Class definition as before...
};

You must also modify two lines of code at the beginning of the SketcherView.cpp file that refer to the base class for CSketcherView. You need to replace CView with CScrollView as the base class:

IMPLEMENT_DYNCREATE(CSketcherView, CScrollView)
        
BEGIN_MESSAGE_MAP(CSketcherView, CScrollView)

However, this is still not quite enough. The new view class needs to know some things about the area you are drawing on and want to scroll, such as its size and how far the view is to be scrolled when you use the scroller. This information must be supplied before the view is drawn. You can put the code to do this in the OnInitialUpdate() function in the view class because this will be called after the view is attached to the document but before the view is displayed.

You supply the information required for scrolling by calling the SetScrollSizes() function that is inherited from the CScrollView class. The arguments to this function are explained in Figure 15-1.

Scrolling a distance of one line occurs when you click on the up or down arrow on the scroll bar; a page scroll occurs when you click the scrollbar itself. You have an opportunity to change the mapping mode here. MM_LOENGLISH would be a good choice for the Sketcher application, but we will first get scrolling working with the MM_TEXT mapping mode because there are still some difficulties to be uncovered.

To add the code to call SetScrollSizes(), you need to override the default version of the OnInitialUpdate() function in the view. You access this in the same way as for the OnUpdate() function override — through the Properties window for CSketcherView. After you have added the override, add the code to the function where indicated by the comment:

void CSketcherView::OnInitialUpdate()
{
  CScrollView::OnInitialUpdate();
        
  CSize DocSize {20000,20000};                    // The document size

  // Set mapping mode and document size
  SetScrollSizes(MM_TEXT, DocSize, CSize {500,500}, CSize {20,20};
}

This maintains the mapping mode as MM_TEXT and defines the total extent that you can draw on as 20,000 pixels in each direction. It also specifies a page scroll increment as 500 pixels in each direction and a line scroll increment as 20 pixels, because the defaults would be too large.

This is enough to get scrolling working after a fashion. Build Sketcher and execute it with these additions. You’ll be able to draw a few elements and then scroll the view. However, although the window scrolls OK, if you try to draw more elements with the view scrolled, things don’t work as they should. The elements appear in a different position from where you draw them and they’re not displayed properly. What’s going on?

Logical Coordinates and Client Coordinates

The problem is because of the coordinate systems you’re using — and that plural is deliberate. You have been using two coordinate systems in all the examples up to now, although you may not have noticed because they were coincident. When you call a function such as LineTo() for a CDC object it assumes that the arguments you pass to it are logical coordinates. 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 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, client coordinates and the logical coordinates in the device context are both in pixels, and so they are 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 well 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, but the origins for the coordinates systems are different. This situation is illustrated in Figure 15-2.

The left side of Figure 15-2 shows the position in the client area where you draw, and the points that are the mouse cursor 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 as arguments to the drawing functions. When the view is scrolled, the line appears displaced because the logical origin has been relocated.

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

// 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
}

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
 
  // Verify the left button is down and mouse messages captured
  if((nFlags&MK_LBUTTON)&&(this==GetCapture()))
  {
     m_SecondPoint = point;          // Save the current cursor position
 
    // Rest of the function as before...
  }
}

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 {dynamic_cast<CElement*>(pHint)->GetEnclosingRect()};
     aDC.LPtoDP(aRect);
     InvalidateRect(aRect);          // Get the area redrawn
  }
  else
  {
    InvalidateRect(nullptr);         // Invalidate the client area
  }
}

void CSketcherView::OnLButtonUp(UINT nFlags, CPoint point)
{
  if(this == GetCapture())
    ReleaseCapture();                // Stop capturing mouse messages
 
  // Make sure there is an element
  if(m_pTempElement)
  { 
     CRect aRect {m_pTempElement->GetEnclosingRect()}; // Get enclosing rectangle
    
    GetDocument()->AddElement(m_pTempElement);   // Add element pointer to sketch
     
     CClientDC aDC {this};                       // Create a device context
     OnPrepareDC(&aDC);                          // Get origin adjusted
     aDC.LPtoDP(aRect);                          // Convert to client coordinates
     InvalidateRect(aRect);                      // Get the area redrawn
    m_pTempElement.reset();                      // Reset pointer to nullptr
   }
}

Using MM_LOENGLISH Mapping Mode

The advantage of using the MM_LOENGLISH mapping mode is that it provides drawings in logical units of 0.01 inches, which ensures that the drawing size is the same on displays at different resolutions. This makes the application much more satisfactory from the user’s point of view.

You can set the mapping mode in the call to SetScrollSizes() made from the OnInitialUpdate() function in the view class. You also need to specify the total drawing area: if you define it as 3,000 by 3,000, this provides a drawing area of 30 inches by 30 inches, which should be adequate. The default scroll distances for a line and a page are satisfactory, so you don’t need to specify those. You can use the Class View to get to the OnInitialUpdate() function and then change it to the following:

void CSketcherView::OnInitialUpdate(void)
{
   CScrollView::OnInitialUpdate();
   
   CSize DocSize {3000,3000};               // Document 30x30ins in MM_LOENGLISH
   SetScrollSizes(MM_LOENGLISH, DocSize);   // Set mapping mode and document size
}

That’s all you need to enable the view to work in MM_LOENGLISH. Note that you are not limited to setting the mapping mode once and for all. You can change the mapping mode in a device context at any time and draw different parts of a view using different mapping modes. A function, SetMapMode(), is used to do this, but I won’t be going into this any further here. Whenever you create a CClientDC object for the view and call OnPrepareDC(), the device context that it owns has the mapping mode you’ve set in the OnInitialUpdate() function. That should do it for the program as it stands. If you build Sketcher, you should have scrolling working, with support for multiple views.

Associating a Menu with a Class

To associate the context menu with the view class, go to the Class View pane and display the Properties window for CSketcherView by right-clicking the class name and selecting Properties from the pop-up. If you click the Messages button in the Properties window, you’ll be able to add a handler for the WM_CONTEXTMENU message by selecting <Add>OnContextMenu from the adjacent cell in the right column. This handler is called when the user right-clicks in the view. The first argument passed to the handler is a pointer to the window in which the user right-clicked, and the second argument is the cursor position in screen coordinates.

Add the following code to the handler:

void CSketcherView::OnContextMenu(CWnd* pWnd, CPoint point)
{
  CMenu menu;
  menu.LoadMenu(IDR_CONTEXT_MENU);              // Load the context menu 
  CMenu* pContext {menu.GetSubMenu(m_pSelected ? 0 : 1)};         
  ASSERT(pContext != nullptr);                  // Ensure it's there

  pContext->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,
                                                point.x, point.y, this);
}

Don’t forget to uncomment the parameter names. This handler displays the first menu in the context menu when m_pSelected points to an element, and the second menu when it does not. Calling the LoadMenu() function for the menu object loads the menu resource corresponding to the ID supplied as the argument and attaches it to the CMenu object. The GetSubMenu() function returns a pointer to the context menu corresponding to the integer argument that specifies the position of the context menu in the CMenu object, with 0 being the first, 1 being the second, and so on. After ensuring the pointer returned by GetSubMenu() is not nullptr, you display the context menu by calling TrackPopupMenu(). The ASSERT macro only operates in the debug version of the program. It produces no code in the release version.

The first argument to the TrackPopupMenu() function consists of two flags ORed together. One flag specifies how the pop-up menu should be positioned and can be any of the following values:

1. TPM_CENTERALIGN centers the pop-up horizontally relative to the x-coordinate supplied as the second argument to the function.
2. TPM_LEFTALIGN positions the pop-up so that the left side of the menu is aligned with the x-coordinate supplied as the second argument to the function.
3. TPM_RIGHTALIGN positions the pop-up so that the right side of the menu is aligned with the x-coordinate supplied as the second argument to the function.

This is just a selection of the options. There are more options available which you can find in the documentation.

The other flag specifies the mouse button and can be either of the following values:

1. TPM_LEFTBUTTON specifies that the pop-up only tracks the left mouse button.
2. TPM_RIGHTBUTTON specifies that the pop-up tracks either the left or the right mouse button.

The next two arguments to TrackPopupMenu()specify the x- and y-coordinates of the context menu in screen coordinates. The y-coordinate determines the position of the top of the menu. The fourth argument specifies the window that owns the menu and that should receive all WM_COMMAND messages from the menu.

Now you can add the handler for the item in the context menu for moving elements. Return to the Resource View and double-click on IDR_CONTEXT_MENU. Right-click the Move menu item and then select Add Event Handler from the menu. It’s a COMMAND handler and you create it in the CSketcherView class. Click the Add and Edit button to create the handler function. You can follow the same procedure to create the handler for the Delete menu item.

Checking Context Menu Items

You don’t have to do anything for COMMAND events for the no element menu items, as you already have handlers for them in the document class. These will automatically take care of the messages from the pop-up items. However, the menu items are in a separate resource, and the menu items will not get checked to reflect the currently selected element type and color. You can fix this in the OnContextMenu() handler, before the context menu is displayed.

The CMenu class has a CheckMenuItem() member that checks a menu item. This function checks or unchecks any item in the menu. The first argument selects which item in the menu is to be checked or unchecked; the second argument is a combination of two flags, one of which determines how the first argument specifies which item is to be checked, and the other specifies whether the menu item is to be checked or unchecked. Because each flag is a single bit in a UINT value, you combine the two using the bitwise OR. The second argument can contain the flag MF_BYCOMMAND if the first parameter is a menu ID or it can contain the flag MF_BYPOSITION which implies the first argument is an index. You can use the former because you know the element IDs. If the second argument contains the MF_CHECKED flag, the item will be checked; the MF_UNCHECKED flag indicates the opposite. Here’s how you can implement checking for the no element menu items:

void CSketcherView::OnContextMenu(CWnd* pWnd, CPoint point)
{
  CMenu menu;
  menu.LoadMenu(IDR_CONTEXT_MENU);              // Load the context menu
  CMenu* pContext {};
  if(m_pSelected)
  {
    pContext = menu.GetSubMenu(0);  
  }
  else
  {
    pContext = menu.GetSubMenu(1);  

    // Check color menu items
    ElementColor color {GetDocument()->GetElementColor()};
    menu.CheckMenuItem(ID_COLOR_BLACK,
        (ElementColor::BLACK == color ? MF_CHECKED : MF_UNCHECKED)| MF_BYCOMMAND);
    menu.CheckMenuItem(ID_COLOR_RED,
          (ElementColor::RED == color ? MF_CHECKED : MF_UNCHECKED)| MF_BYCOMMAND);
    menu.CheckMenuItem(ID_COLOR_GREEN,
        (ElementColor::GREEN == color ? MF_CHECKED : MF_UNCHECKED)| MF_BYCOMMAND);
    menu.CheckMenuItem(ID_COLOR_BLUE,
         (ElementColor::BLUE == color ? MF_CHECKED : MF_UNCHECKED)| MF_BYCOMMAND);

    // Check element menu items
    ElementType type {GetDocument()->GetElementType()};
    menu.CheckMenuItem(ID_ELEMENT_LINE,
          (ElementType::LINE == type ? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
    menu.CheckMenuItem(ID_ELEMENT_RECTANGLE,
      (ElementType::RECTANGLE == type? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
    menu.CheckMenuItem(ID_ELEMENT_CIRCLE,
         (ElementType::CIRCLE == type? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);
    menu.CheckMenuItem(ID_ELEMENT_CURVE,
         (ElementType::CURVE == type? MF_CHECKED : MF_UNCHECKED) | MF_BYCOMMAND);  
  }   
  ASSERT(pContext != nullptr);                  // Ensure it's there

  pContext->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,
                                                point.x, point.y, this);
}

That’s the context menu finished. You need to identify when an element is under the cursor next.

Exercising the Context Menus

You have added all the code you need to make the context menus operate, so you can build and execute Sketcher to try them out. When you right-click the mouse a context menu will be displayed. If there are no elements under the cursor, the second context pop-up appears, enabling you to change the element type and color. These options work because they generate exactly the same messages as the main menu options for which you have already written handlers.

If there is an element under the cursor, the first context menu will appear with Move and Delete on it. It won’t do anything at the moment, as you’ve yet to implement the handlers for the messages. Try right-button clicks outside the view window. Messages for these are not passed to the view window in your application, so the pop-up is not displayed.

Highlighting Elements

Ideally, the user will want to know which element is under the cursor before right-clicking to get the context menu. When you intend to delete an element, you want to be sure which element you are operating on. If there are concentric circles displayed, only one will be selected but you won’t know which. Equally, when you want to use the other context menu — to change the drawing color for example — you must be sure no element is under the cursor when you right-click the mouse, otherwise you’ll get the Move/Delete menu displayed. To show which element is under the cursor, you need to highlight it in some way before a right-button click occurs.

You can change the Draw() member function for each element type to accommodate this. You can pass an extra argument to the Draw() function to indicate when the element should be highlighted. If you pass the address of the currently selected element that you save in the m_pSelected member of the view to the Draw() function for an element, you can pass it on to the CreatePen() function, which can compare it to the this pointer to decide the color of the pen.

Highlighting will work in the same way for all element types, so let’s take the CLine member as an example. You can add similar code to each of the classes for the other element types. Before you start changing CLine, you must first amend the definition of the base class CElement:

 
static const COLORREF SELECT_COLOR{RGB(255,0,180)};    // Highlight color
 
class CElement : public CObject
{
protected:
  CPoint m_StartPoint;                           // Element position      
  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, std::shared_ptr<CElement> pElement=nullptr) {} 
 
  // Get the element enclosing rectangle 
  const CRect& GetEnclosingRect() const 
  {
    return m_EnclosingRect;
  }
 
protected:
  // Constructors protected so they cannot be called outside the class
  CElement();              
  CElement(const CPoint& start, COLORREF color, int penWidth = 1);
 
  // Create a pen
  void CreatePen(CPen& aPen, std::shared_ptr<CElement> pElement)
  {
    if(!aPen.CreatePen(PS_SOLID, m_PenWidth,
     this == pElement.get() ? SELECT_COLOR : m_Color))
    {
      // Pen creation failed
      AfxMessageBox(_T("Pen creation failed"), MB_OK);
      AfxAbort();
    }
  }
};

You need an #include directive for the memory header in Element.h. SELECT_COLOR is the highlight color for all elements and this is a static constant that is defined and initialized at a global scope. A second parameter has been added to the virtual Draw() function. This is a pointer to an element and it will be used when an element is to be highlighted because it is under the mouse cursor. With the second parameter initialized to nullptr, the function can still be called with just one argument; the second argument will be nullptr by default.

The CreatePen() function also has an additional argument that is a pointer to an element. When pElement contains the address of the current element, the pen is created using the highlight color.

You need to modify the declaration of the Draw() function in each of the definitions for the classes derived from CElement in exactly the same way. For example, you should change the CLine class definition to:

class CLine :
  public CElement
{
public:
  virtual ~CLine(void); 
  // Function to display a line
  virtual void Draw(CDC* pDC, std::shared_ptr<CElement> pElement=nullptr)
                                                                     override;
 
      // Rest of the class as before...
};

The implementations for the Draw() functions for the derived classes also need to be extended in the same way. For the CLine class it is:

void CLine::Draw(CDC* pDC, std::shared_ptr<CElement> pElement)
{
  // Create a pen for this object and initialize it
  CPen aPen;
  CreatePen(aPen, pElement);
 
  // Rest of the function body as before...
}

This is a very simple change. The second argument to the CreatePen() function call is the pElement smart pointer that is passed as the second argument to the Draw() function.

You have nearly implemented element highlighting. The derived classes of the CElement class are now able to draw themselves as highlighted when required — you just need a mechanism to cause an element to be selected. So where should you create this? You can determine which element, if any, is under the cursor in the OnMouseMove() handler in the CSketcherView class, so that’s obviously the place to expedite the highlighting.

The amendments to the OnMouseMove() handler are as follows:

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
 
  // Verify the left button is down and mouse messages captured
  if((nFlags & MK_LBUTTON) && (this == GetCapture()))
  {
    // Code as before...
  }
  else
  { // We are not creating an element, so do highlighting
    auto pOldSelected = mp_Selected;                   // Copy previous
    m_pSelected = GetDocument()->FindElement(point);
    if(m_pSelected != pOldSelected)
    {
      if(m_pSelected)
        GetDocument()->UpdateAllViews(nullptr, 0, m_pSelected.get());
      if(pOldSelected)
        GetDocument()->UpdateAllViews(nullptr, 0, pOldSelected.get());
    }
  }
}

You must keep track of any previously highlighted element before you store the address of a new one. If there’s a new element to be highlighted, you must un-highlight the old one. To do this, you save a copy of m_pSelected in pOldSelected before you check for a selected element. You then store the smart pointer returned by the FindElement() function for the document object in m_pSelected.

If pOldSelected and m_pSelected are equal, then either they both contain the address of the same element or they are both nullptr. If they both contain a valid address, the element will already have been highlighted last time around. If they are both nullptr, nothing is highlighted and nothing needs to be done. Thus, in either case, you do nothing.

Thus, you want to do something only when m_pSelected is not equal to pOldSelected. If m_pSelected is not nullptr, you need to get it redrawn, so you call UpdateAllViews() with the first argument as nullptr to get all views updated, and the third argument as m_pSelected.get()identify the region to be updated. If pOldSelected is also not nullptr, you must un-highlight the old element by updating its area in the same way. The updating of each view will be done by its OnUpdate() member, which will invalidate the rectangle enclosing the element. Only the currently active view will have element highlighting active.

void CSketcherView::OnDraw(CDC* pDC)
{
  CSketcherDoc* pDoc = GetDocument();
  ASSERT_VALID(pDoc);
  if (!pDoc)
    return;
        
  // Draw the sketch
  for (const auto& pElement : *pDoc)
  {
    if (pDC->RectVisible(pElement->GetEnclosingRect())) // Element visible?
      pElement->Draw(pDC, m_pSelected);                 // Yes, draw it.
  }
}

Implementing Move and Delete

The next step is to provide code in the bodies of the handlers in the view class for the Move and Delete menu items that you added earlier. You can add the code for Delete first because that’s the simpler of the two.

void CSketcherView::OnElementDelete()
{
  if(m_pSelected)
  {
    GetDocument()->DeleteElement(m_pSelected);         // Delete the element
    m_pSelected.reset();
  }
}

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
  CPoint m_CursorPos;          // Cursor position
  CPoint m_FirstPos;           // Original position in a move
  std::shared_ptr<CElement> m_pTempElement;
  std::shared_ptr<CElement> m_pSelected;    // Records element under the cursor
  bool m_MoveMode {false};     // Move element flag
 
// Rest of the class as before...
};

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
}

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
  if(m_MoveMode)
  {
    MoveElement(aDC, point);         // Move the element
  }
  else if((nFlags & MK_LBUTTON) && (this == GetCapture()))  
  {
   // Rest of the mouse move handler as before...
  }
}

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

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 element to erase it
    m_pSelected->Move(distance);          // Now move the element
    m_pSelected->Draw(&aDC, m_pSelected); // Draw the moved element
  }
}

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)
  {
    CSketcherDoc* pDoc {GetDocument()};                // Get the document pointer

    pDoc->UpdateAllViews(this, 0L, m_pSelected.get()); // Update all except this
 
    aDC.SetROP2(R2_NOTXORPEN);
    m_pSelected->Draw(&aDC, m_pSelected);              // Draw element to erase it
    m_pSelected->Move(distance);                       // Now move the element
    m_pSelected->Draw(&aDC, m_pSelected);              // Draw the moved element
 
    pDoc->UpdateAllViews(this, 0 , m_pSelected.get()); // Update all except this
  }
}

class CElement : public CObject
{
protected:
  CPoint m_StartPoint;                           // Element position      
  int m_PenWidth;                                // Pen width
  COLORREF m_Color;                              // Color of an element
  CRect m_EnclosingRect;                         // Rectangle enclosing an element
 
public:
  virtual ~CElement();
  virtual void Draw(CDC* pDC, std::shared_ptr<CElement> pElement=nullptr) {} 
  virtual void Move(const CSize& aSize){}        // Move an element
        
  // Rest of the class as before...
        
};

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

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
}

void CRectangle::Move(const CSize& aSize)
{
  m_StartPoint += aSize;               // Move the start point
  m_BottomRight += aSize;              // Move the bottom right point
  m_EnclosingRect += aSize;            // Move the enclosing rectangle
}

void CCircle::Move(const CSize& aSize)
{
  m_StartPoint += aSize;               // Move the start point
  m_BottomRight += aSize;              // Move the bottom right point
  m_EnclosingRect += aSize;             // Move the enclosing rectangle
}

void CCurve::Move(const CSize& aSize)
{
  m_EnclosingRect += aSize;            // Move the rectangle
  m_StartPoint += aSize;               // Move the start point
  // Now move all the other points
  for(auto& p : m_Points)
    p += aSize;
}

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
        
  if(m_MoveMode)
  {
    // In moving mode, so drop the element
    m_MoveMode = false;                // Kill move mode
    auto pElement(m_pSelected);        // Store selected address
    m_pSelected.reset();               // De-select the element
    GetDocument()->UpdateAllViews(nullptr, 0,
                                      pElement.get());  // Redraw all the views
  }
  else
  {
    m_FirstPoint = point;              // Record the cursor position
    SetCapture();                      // Capture subsequent mouse messages
  }
}

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.reset();                    // De-select element
     GetDocument()->UpdateAllViews(nullptr); // Redraw all the views
  }
}

void CSketcherView::OnRButtonUp(UINT nFlags, CPoint point)
{
  if(m_MoveMode)
  {
    m_MoveMode = false;
  }
  else
  {
      CScrollView::OnRButtonUp(nFlags, point);
  }
}

EXERCISES

1. Implement element highlighting so that the line type changes for the element under the cursor as well as the element color.
2. Change the Sketcher program so that it uses a vector container to store a sketch instead of a list.

WHAT YOU LEARNED IN THIS CHAPTER