Redraw/Repaint code - Gammon Forum

I'm looking at methods_output.cpp, and there's something I'm not getting.

CMUSHclientDoc::Redraw() just calls UpdateAllViews(NULL).
And
CMUSHclientDoc::Repaint() does...

UpdateAllViews (NULL);
for(POSITION pos = GetFirstViewPosition(); pos != NULL; )
{
  CView* pView = GetNextView(pos);
  if (pView->IsKindOf(RUNTIME_CLASS(CMUSHView)))
  {
     CMUSHView* pmyView = (CMUSHView*)pView;
     pmyView->UpdateWindow ();
  } // end of being a CMUSHView
} // end of loop through views

Which is oddly similar to a combination of Redraw() and this example code for CDocument::GetFirstViewPosition (MFC) from http://msdn.microsoft.com/en-us/library/ysfkkk2h%28VS.80%29.aspx

// This example uses CDocument::GetFirstViewPosition
// and GetNextView to repaint each view.
void CMyDoc::OnRepaintAllViews()
{
  POSITION pos = GetFirstViewPosition();
  while (pos != NULL)
  {
    CView* pView = GetNextView(pos);
    pView->UpdateWindow();
  }   
}

// An easier way to accomplish the same result is to call
// UpdateAllViews(NULL);

Notice that comment at the bottom. MSDN appears to be claiming that Repaint() is just like calling Redraw() twice, with the minor difference of your CMUSHView pointer shuffling (what is that for?).
Indeed, the example code for CDocument::UpdateAllViews (MFC) from http://msdn.microsoft.com/en-us/library/eys41xfw%28VS.80%29.aspx is

void CMyDoc::OnRepaintAllViews()
{
   UpdateAllViews(NULL);
}

Which is the same function declaration as above. So what's going on here?

Never mind what the comments say. Look at the descriptions for the APIs.

(my emphasis below)

CDocument::UpdateAllViews calls CView::OnUpdate for each view.

CView::OnUpdate does this:



Called by the framework after the view's document has been modified; this function is called by CDocument::UpdateAllViews and allows the view to update its display to reflect those modifications. It is also called by the default implementation of OnInitialUpdate. The default implementation invalidates the entire client area, marking it for painting when the next WM_PAINT message is received.

So basically UpdateAllViews invalidates (marks for painting) all windows. However it doesn't actually draw them. That is done in the main message loop when Windows notices that there are views with invalidated regions, and then sends them a WM_PAINT message. (This causes the OnDraw function to be called to actually draw the window).

Meanwhile CWnd::UpdateWindow does this:



Updates the client area by sending a WM_PAINT message if the update region is not empty. The UpdateWindow member function sends a WM_PAINT message directly, bypassing the application queue. If the update region is empty, WM_PAINT is not sent.

So this sends the WM_PAINT message now rather than in the future. In my Repaint function I first call UpdateAllViews (NULL) in order to satisfy the condition that the update region is not empty.

To summarise:

Redraw invalidates but doesn't paint.
Repaint immediately paints.

Note that the documenation for WM_PAINT says:



The system sends this message when there are no other messages in the application's message queue. 



DispatchMessage determines where to send the message; GetMessage determines which message to dispatch. GetMessage returns the WM_PAINT message when there are no other messages in the application's message queue, and DispatchMessage sends the message to the appropriate window procedure.

This makes invalidating the window effectively marking the painting as low priority. So if there is a queue of mouse-downs, key-presses, incoming network messages, etc. these are processed first.

The comment about "An easier way to accomplish the same result is to call UpdateAllViews(NULL);" is a bit misleading. It accomplishes a similar result, but a deferred result. It isn't the identical result.