examples/Graphics/coverflow/src/dialogbox.cpp

Go to the documentation of this file.

/*
Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
� list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
� this list of conditions and the following disclaimer in the documentation
� and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
� may be used to endorse or promote products derived from this software
� without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description:� 
*/
#include "dialogbox.h"

CDialogBox::CDialogBox(const TRect& aRect):
        iRect(aRect)
        {
        }

CDialogBox* CDialogBox::NewL(const TRect& aRect)
        {
        CDialogBox* self = new(ELeave) CDialogBox(aRect);
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop(self);
        return self;
        }

void CDialogBox::ConstructL()
        {
        // Connects the client session to the window server.
        User::LeaveIfError(iWs.Connect());
        
        // Constructs a new screen device attached to a particular window server session.
        iScr = new(ELeave) CWsScreenDevice(iWs);
        User::LeaveIfError(iScr->Construct());
        
        // Constructs a graphics context.
        iGc = new(ELeave) CWindowGc(iScr);
        User::LeaveIfError(iGc->Construct());
        
        // Creates a sessionless, uninitialised window group handle.
        iGrp = RWindowGroup(iWs);
        User::LeaveIfError(iGrp.Construct(0xdeadface, EFalse));
        iGrp.SetOrdinalPositionErr(0, 100);
        
        // Creates a sessionless, uninitialised window handle.
        iWin = RWindow(iWs);
        User::LeaveIfError(iWin.Construct(iGrp, (TInt)this));
        
        // Sets the window to be transparent using the alpha channel.
        iWin.SetTransparencyAlphaChannel();
        
        // Sets the background colour used for clearing in server-initiated redraws.
        iWin.SetBackgroundColor(TRgb(0,0,0,0));
        
        // Sets the size and position of a window.
        iWin.SetExtent(iRect.iTl, iRect.Size());
        
        // Displays the window and enables it to receive events.
        iWin.Activate();
        
        // Sets the ordinal position of a window.
        iWin.SetOrdinalPosition(-1);
        
        // Sets the window's visibility.
        iWin.SetVisible(EFalse);
        
        // Sends all pending commands in the buffer to the window server.
        iWs.Flush();
        
        // Allocates and constructs a CPeriodic object. Assign a priority to it.
        iTimer = CPeriodic::NewL(CActive::EPriorityStandard);
        
        // Appends CLoader objects in to the array.
        iLoaders.AppendL(CLoader::NewL(KCallBitmaps1));
        iLoaders.AppendL(CLoader::NewL(KCallBitmaps2));
        iLoaders.AppendL(CLoader::NewL(KCallBitmaps3));
        iLoaders.AppendL(CLoader::NewL(KCallBitmaps4));
        iLoaders.AppendL(CLoader::NewL(KCallBitmaps5));
        iLoaders.AppendL(CLoader::NewL(KCallBitmaps6));

        for (TInt ii=0; ii < 6; ii++)
                {
                iLoaders[ii]->Decode();
                iCallBuffer.AppendL(iLoaders[ii]->iBitmap);
                iCallBuffer.AppendL(iLoaders[ii]->iMask);
                }

        iImageCounter = 0;
        iSemiTransFlag = EFalse;

        }
        
CDialogBox::~CDialogBox()
        {
        Stop();
        delete iTimer;
        
        iCallBuffer.ResetAndDestroy();
        iLoaders.ResetAndDestroy();

        delete iGc;
        delete iScr;
        
        // Close the nodes.
        iWin.Close();
        iGrp.Close();
        iWs.Close();
        }
        
void CDialogBox::Start()
        {
        // Sets the window's visibility.
        iWin.SetVisible(ETrue);
        if (!iTimer->IsActive())
                {
                // Starts generating periodic events. Pass the OnTick() function to call when the CPeriodic is scheduled after a timer event.
                iTimer->Start(0, 150*1000, TCallBack(CDialogBox::OnTick, this));
                }
        }
        
void CDialogBox::Stop()
        {
        // Sets the window's visibility.
        iWin.SetVisible(EFalse);
        
        // Sends all pending commands in the buffer to the window server.
        iWs.Flush();
        
        // Cancels the wait for completion of an outstanding request.
        iTimer->Cancel();
        }
        
TInt CDialogBox::OnTick(TAny* aArg)
        {
        CDialogBox* self = (CDialogBox*)aArg;
        
        // Invalidates the entire window.
        self->iWin.Invalidate();
        
        // Begins redrawing the window's invalid region
        self->iWin.BeginRedraw();
        
        // Activates the context for a given window 
        self->iGc->Activate(self->iWin);
        self->Draw();
        
        // Frees the graphics context to be used with another window.
        self->iGc->Deactivate();
        
        // Ends the current redraw.
        self->iWin.EndRedraw();
        
        // Sends all pending commands in the buffer to the window server.
        self->iWs.Flush();

        return 0;
        }
        
TBool CDialogBox::Draw()
        {
        if(iImageCounter == 12)
                iImageCounter = 0;
        iCallFrame = iCallBuffer[iImageCounter++];
        iCallMaskFrame = iCallBuffer[iImageCounter++];
        
        // Performs a masked bitmap block transfer of a memory resident source bitmap.
        iGc->BitBltMasked(TPoint(10,10), iCallFrame, iCallFrame->SizeInPixels(), iCallMaskFrame, EFalse);

        return EFalse;
        }
void CDialogBox::SetSemiTransparency()
        {
        iWin.SetBackgroundColor(TRgb(24,255,0,128));
        iSemiTransFlag = ETrue;
        }
        
void CDialogBox::RemoveSemiTransparency()
        {
        iWin.SetBackgroundColor(TRgb(0,0,0,0));
        iSemiTransFlag = EFalse;
        }

CLoader* CLoader::NewL(const TDesC& aFn)
        {
        CLoader* self = new(ELeave) CLoader;
        CleanupStack::PushL(self);
        self->ConstructL(aFn);
        CleanupStack::Pop();
        return self;
        }
        
void CLoader::ConstructL(const TDesC& aFn)
        {
        iBitmap = new(ELeave) CFbsBitmap;
        User::LeaveIfError(iBitmap->Load(aFn, 0));

        iMask = new(ELeave) CFbsBitmap;
        User::LeaveIfError(iMask->Load(aFn, 1));

#ifdef PORTRAIT_MODE
        RotateL(*iBitmap);
        RotateL(*iMask);
#endif
        }

CLoader::CLoader()
        {
        }

CLoader::~CLoader()
        {
        // no need to destroy bitmaps because caller take ownership of them
        }

void CLoader::Decode()
        {
        }

#ifdef PORTRAIT_MODE

void CLoader::RotateL(CFbsBitmap& aBitmap)
        {
        CFbsBitmap* tmp = new(ELeave) CFbsBitmap;
        CleanupStack::PushL(tmp);
        
        // Gets the pixel-size of the bitmap. 
        const TSize bSz = aBitmap.SizeInPixels();
        
        // Gets the display mode of the bitmap. 
        const TDisplayMode bMode = aBitmap.DisplayMode();
        const TSize tSz(bSz.iHeight, bSz.iWidth);
        
        // Creates a bitmap with the specified size and display mode
        User::LeaveIfError(tmp->Create(tSz, bMode));
        
        // Gets the address of the first pixel in the bitmap
        TUint8* pTmp = (TUint8*)tmp->DataAddress();

        TInt y = tSz.iHeight - 1;
        TInt scanLineLength = tmp->ScanLineLength(tSz.iWidth,bMode);
        for (TInt x=0; x<bSz.iWidth; ++x)
                {
                TPtr8 buf(pTmp + (y * scanLineLength), scanLineLength);
                
                // Gets the bitmap's vertical scanline starting at the specified x co-ordinate.
                aBitmap.GetVerticalScanLine(buf, x, bMode);

                --y;
                }

        // Swaps the bitmap's width and height.
        User::LeaveIfError(aBitmap.SwapWidthAndHeight());
        Mem::Move(aBitmap.DataAddress(), tmp->DataAddress(), scanLineLength * tSz.iHeight);

        CleanupStack::PopAndDestroy(tmp);
        }

#endif

---