Re: MFC Flicker and the Application Framework

On Tue, 13 Mar 2007 01:49:18 -0700, C Hill MBSC
<CHillMBSC@discussions.microsoft.com> wrote:


Hi,

first to say: there are people much more experienced and authoritative
than me on this newsgroup; the following are just my "2 cents"...


Why #include the main app header here?
Does the view class need it?
If not, better not including it...
I tend to minimize inclusion dependencies.


The above #include ".\flick...." is IMHO a useless line, and
duplicated from the #include "Flick...."
Which version of Visual Studio are you using?
Do Visual Studio guys fixed these *bugs* in VS2005?
(As Joe - one of the "gurus" here - wrote, they think about
"coolness", produce huge software, but avoid more important stuff like
this! [Maybe the focus/hype is now on C#??] What a pity.)

I read in your code that you re-create the same font in OnDraw(), at
each function call.
Do you have flicker? So, try to do as less things as possible in the
drawing handler.
The font is constant, so build it once. I would build this constant
font once in the constructor, so you may add a data member in your
class:

  // View class header
  // ...
  private:
      CFont MyFont;

and init in constructor:

    MyFont.CreatePointFont(240, _T("Arial"));

Note that I decorate strings with _T(...).
It helps a lot in Unicode builds (there are very interesting posts on
this newsgroup about Unicode.)

Moreover, note that I'm using your coding convention for MyFont; but I
prefer using an m_ prefix for the class data members, so I would much
prefer calling your MyFont object "m_myFont" (m_ --> reminds the
reader that it is a member variable).

Moreover, I read in your code that you are doing drawing in the
OnTimer handler.
I would not do this. In the OnTimer, I would do the *update*
operations like "Counter++;", and then request a repaint.
But I would put the drawing routines in OnDraw (or in a separate
member function, to be called in OnDraw).


To avoid flickering, use the very good CMemDC class - if I recall
correctly, Tom wrote also the CodeProject URL; however, here it is:

http://www.codeproject.com/gdi/flickerfree.asp

Build a CMemDC in OnDraw, and do the drawing onto CMemDC instance.
The class will do the double-buffering for you.

Don't forget also to add an OnEraseBackground handler and return
FALSE, to prevent the flickering.

void CFlickeringCounterView::OnDraw(CDC* pDC)
{
    // Memory DC, to prevent flickering
    CMemDC dc(pDC);

    CFlickeringCounterDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    if (!pDoc)
        return;

    // *** Print timer value ***
    m_strCounter.Format(_T("Counter = %d"), m_nCounter);
    CFont * pOldFont = dc.SelectObject(&m_font);
    dc.TextOut(0, 0, m_strCounter);
    dc.SelectObject(pOldFont);
}

Stop here: just updating.
And request a repaint:

void CFlickeringCounterView::OnTimer(UINT nIDEvent)
{
    // Increase counter value
    m_nCounter++;

    // Ask repaint
    Invalidate();
    UpdateWindow();

    CView::OnTimer(nIDEvent);
}

I prefer identifing timers with mnemonics, not with raw numbers.
So I put a TimerID (= 1) constant in the class, and manage the timer
ID via this constant number, rather than raw "1".

Moreover, you have to kill the timer.
Maybe OnDestroy is a good place to do it:

void CFlickeringCounterView::OnDestroy()
{
    CView::OnDestroy();

    // Delete the timer
    KillTimer(TimerID);
}

You might want to consider the following code. I tested it, and there
was no flickering... (both in debug and release build).
Here you can find three source files: the view class .cpp, the view
class .h, and MemDC.h (they are separated by the *---....---* line).

<CODE>

*---------------------------------------------------------*

///////////////////////////////////////////////////////////
// FlickeringCounterView.cpp :
// implementation of the CFlickeringCounterView class
///////////////////////////////////////////////////////////

#include "stdafx.h"
#include "FlickeringCounterDoc.h"
#include "FlickeringCounterView.h"
#include "MemDC.h" // CMemDC - prevent flickering

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// CFlickeringCounterView

IMPLEMENT_DYNCREATE(CFlickeringCounterView, CView)

BEGIN_MESSAGE_MAP(CFlickeringCounterView, CView)
    // Standard printing commands
    ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
    ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
    ON_WM_ERASEBKGND()
    ON_WM_DESTROY()
    ON_WM_CREATE()
    ON_WM_TIMER()
END_MESSAGE_MAP()

// CFlickeringCounterView construction/destruction

CFlickeringCounterView::CFlickeringCounterView()
    : m_nCounter(0)
{
    // Build the font
    VERIFY( m_font.CreatePointFont(240, _T("Arial")) );
}

CFlickeringCounterView::~CFlickeringCounterView()
{
}

BOOL CFlickeringCounterView::PreCreateWindow(CREATESTRUCT& cs)
{
    // TODO: Modify the Window class or styles here by modifying
    // the CREATESTRUCT cs

    return CView::PreCreateWindow(cs);
}

// CFlickeringCounterView drawing

void CFlickeringCounterView::OnDraw(CDC* pDC)
{
    // Memory DC, to prevent flickering
    CMemDC dc(pDC);

    CFlickeringCounterDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    if (!pDoc)
        return;

    // *** Print timer value ***
    m_strCounter.Format(_T("Counter = %d"), m_nCounter);
    CFont * pOldFont = dc.SelectObject(&m_font);
    dc.TextOut(0, 0, m_strCounter);
    dc.SelectObject(pOldFont);
}

// CFlickeringCounterView printing

BOOL CFlickeringCounterView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // default preparation
    return DoPreparePrinting(pInfo);
}

void CFlickeringCounterView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo*
/*pInfo*/)
{
    // TODO: add extra initialization before printing
}

void CFlickeringCounterView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo*
/*pInfo*/)
{
    // TODO: add cleanup after printing
}

// CFlickeringCounterView diagnostics

#ifdef _DEBUG
void CFlickeringCounterView::AssertValid() const
{
    CView::AssertValid();
}

void CFlickeringCounterView::Dump(CDumpContext& dc) const
{
    CView::Dump(dc);
}

CFlickeringCounterDoc* CFlickeringCounterView::GetDocument() const //
non-debug version is inline
{
 ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CFlickeringCounterDoc)));
    return (CFlickeringCounterDoc*)m_pDocument;
}
#endif //_DEBUG