DSA(直接写屏)和双缓冲

#include <W32STD.H> // ws32.lib
    
class CMyDsaAppContainer: public CCoeControl,
        public MDirectScreenAccess
    {
// new functions ++
    ... // other functions
public:
    virtual ~CMyDsaAppContainer();
    void Repaint(const TRect & aRect);
    
protected:
    void ConstructL(const CCoeControl* aParent, const TRect& aRect);

private:
    void PaintUsingDsa(CBitmapContext & aGc, const TRect & aRect);
// new functions --

// from MDirectScreenAccess ++
public:
    
    /** This function is called by the window server when direct screen access must
     * stop (for example because a dialogue is moved in front of the area where direct
     * screen access is taking place).
     * In response to this, direct screen access must stop immediately. In simple cases,
     * this will involve cancelling the active object that is driving the drawing to the
     * screen.
     * No attempt to call a Window Server API function can be made from
     * AbortNow(), because then a temporary deadlock will occur. This is because WSERV
     * is waiting to receive the client's acknowledgment that it has aborted, and so will
     * not be able to service the call. As soon as the restriction no longer applies,
     * the function Restart() will be called.
     *
     * @param aReason The reason why direct screen access was terminated.
     */
    void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);
    
    /** This function is called by the window server as soon as direct screen access
     * can resume.
     * This function should call CDirectScreenAccess::StartL() within a trap harness.
     * If this leaves, e.g. through lack of memory, direct screen access cannot be
     * restarted. StartL() re-calculates the clipping region, so that if direct screen
     * access was aborted because another window appeared in front of it, that window
     * will not be overwritten when direct screen access resumes.
     * In this function, you can resume calls to Window Server Client Side API functions.
     *
     * @param aReason Provides the reason why direct screen access was terminated.
     */
    void Restart(RDirectScreenAccess::TTerminationReasons aReason);
// from MDirectScreenAccess --
    
    ... // other functions
    
private:
    CDirectScreenAccess * iDsa;
    ... // other member data
    };

CMyDsaAppContainer::~CMyDsaAppContainer()
    {
    ...
    iDsa->Cancel();
    delete iDsa;
    ...
    }

void CMyDsaAppContainer::Repaint(const TRect & /*aRect*/)
    {
    TRect rect = Rect();
    PaintUsingDsa(*iDsa->Gc(), rect); // drawing with DSA
    iDsa->ScreenDevice()->Update();
    }

void CMyDsaAppContainer::ConstructL(const CCoeControl* aParent,
        const TRect& aRect)
    {
    ...
    iDsa = CDirectScreenAccess::NewL(CEikonEnv::Static()->WsSession(),
            *(CEikonEnv::Static()->ScreenDevice()), Window(), *this);
    iDsa->StartL();
    ...
    }

void CMyDsaAppContainer::PaintUsingDsa(CBitmapContext & aGc,
        const TRect & aRect)
    {
    // draw with aGc
    aGc.DrawLine(...);
    ...
    }

void CMyDsaAppContainer::AbortNow(
        RDirectScreenAccess::TTerminationReasons aReason)
    {
    ...
    iDsa->Cancel();
    ...
    }

void CMyDsaAppContainer::Restart(
        RDirectScreenAccess::TTerminationReasons aReason)
    {
    TRect rect = Rect();
    ...
    iDsa->StartL();
    Repaint(rect);
    ...
    }


#include <W32STD.H> // ws32.lib
    
// protected
void CMyOffScreenPainter::ConstructL()
    {
    iOffScreenBmp = new (ELeave) CWsBitmap(CEikonEnv::Static()->WsSession());
    
    CWsScreenDevice* screenDev = CEikonEnv::Static()->ScreenDevice();
    
    User::LeaveIfError(iOffScreenBmp->Create(screenDev->SizeInPixels(),
            screenDev->DisplayMode()));
    
    iOffScreenDev = CFbsBitmapDevice::NewL(iOffScreenBmp);
    
    // iOffScreenGc is an instance of CFbsBitGc
    User::LeaveIfError(iOffScreenDev->CreateContext(iOffScreenGc));
    ... // other code
    }

void CMyOffScreenPainter::SizeChanged()
    {
    TRect rect = Rect();
    User::LeaveIfError(iOffScreenBmp->Resize( rect.Size() ));
    User::LeaveIfError(iOffScreenDev->Resize( rect.Size() ));
    iOffScreenGc->Resized();
    ... // other code
    }

void CMyOffScreenPainter::DrawWithOffScreenBmp()
    {
    iOffScreenGc->DrawArc(...);
    ... // some code about drawing
    }

void CMyOffScreenPainter::Draw(const TRect & /*aRect*/)
    {
    CWindowGc & gc = SystemGc();
    
    // draw the offscreen bmp to srcreen
    gc.BitBlt( Position(), iOffScreenBmp);
    ... // other code
    }

CMyOffScreenPainter::~CMyOffScreenPainter()
    {
    delete iOffScreenGc; iOffScreenGc = NULL;
    delete iOffScreenDev; iOffScreenDev = NULL;
    delete iOffScreenBmp; iOffScreenBmp = NULL;
    ... // other code
    }