/*
* Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:   
*
*/



#include "huicanvasbackground.h"
#include "huicanvasgc.h"
#include <uiacceltk/HuiSkin.h>
#include <uiacceltk/HuiS60Skin.h>
#include <uiacceltk/HuiCanvasVisual.h>
#include <uiacceltk/HuiDisplay.h>
#include <uiacceltk/HuiStatic.h>
#include <uiacceltk/HuiEnv.h>

#include <e32cmn.h>


// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CHuiCanvasBackground::CHuiCanvasBackground()
    {	    
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CHuiCanvasBackground::~CHuiCanvasBackground()
    {
    iBackgroundItems.Close();
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHuiCanvasBackground* CHuiCanvasBackground::NewL()
    {
    CHuiCanvasBackground* self = CHuiCanvasBackground::NewLC();
    CleanupStack::Pop(self);
    return self;        
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHuiCanvasBackground* CHuiCanvasBackground::NewLC()
    {
    CHuiCanvasBackground* self = new (ELeave) CHuiCanvasBackground();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::SetVisual(CHuiCanvasVisual* aVisual)
    {
    iCanvasVisual = aVisual;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::SetClearBackground(CHuiDisplay::TClearMode aClearBackground)
    {
    iClearBackground = aClearBackground;    
    iBackgroundItems.Reset();
    if(aClearBackground == CHuiDisplay::EClearWithSkinBackground)
        {
        TRAP_IGNORE(CHuiStatic::Env().Skin().TextureL(EHuiSkinBackgroundTexture));
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TInt CHuiCanvasBackground::ClearBackground()
    {
    return iClearBackground;        
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//

TInt CHuiCanvasBackground::BackgroundItemsCount()
    {
    return iBackgroundItems.Count();        
    }
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::SetBackgroundColor(const TRgb& aBackgroundColor)
    {
    iBackgroundColor = aBackgroundColor;    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TRgb CHuiCanvasBackground::BackgroundColor() const
    {
    return iBackgroundColor;    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::SetBackgroundItems(const RArray<THuiDisplayBackgroundItem>& aItems)
    {
    iClearBackground = CHuiDisplay::EClearNone;
    iBackgroundItems.Reset();
    for(TInt i = 0; i < aItems.Count(); ++i)
        {
        iBackgroundItems.Append(aItems[i]);
        }   
    if (!CHuiStatic::Env().Renderer() == EHuiRendererBitgdi)
        {
        CHuiS60Skin* s60skin = static_cast<CHuiS60Skin*>(&CHuiStatic::Env().Skin());
        TRAP_IGNORE(s60skin->UpdateBackgroundsL(iBackgroundItems));
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::GetBackgroundItems(RArray<THuiDisplayBackgroundItem>& aItems)
    {
    aItems.Reset();
    for(TInt i = 0; i < iBackgroundItems.Count(); ++i)
        {
        aItems.Append(aItems[i]);
        }   
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::DrawSelf(CHuiGc& aGc, const TRect& aDisplayRect)
    {
	iCanvasVisual->CanvasGc().SetGc(aGc);
	    
    // Clear background for the dirty area
    if (iBackgroundItems.Count() != 0)
        {
        ClearWithBackgroundItems(aDisplayRect);    
        }
    else
        {
        switch (iClearBackground)
            {
            case CHuiDisplay::EClearWithColor:
                {
                ClearWithColor(aGc, aDisplayRect);                            
                break;    
                }
            case CHuiDisplay::EClearWithSkinBackground:
                {
                ClearWithSkinBackground(aDisplayRect);                                                    
                break;    
                }
            case CHuiDisplay::EClearNone:
            default:
                {
                // Don't do anything
                break;    
                }                                                
            }                                    
        }                                                
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::ClearWithBackgroundItems(const TRect& aDisplayRect)
    {    
    if (!iCanvasVisual)
        {
        return;    
        }

    CHuiCanvasGc& canvasGc = iCanvasVisual->CanvasGc();
    canvasGc.ClearWithBackgroundItems(aDisplayRect, iBackgroundItems);    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::ClearWithSkinBackground(const TRect& aDisplayRect)
    {    
    if (!iCanvasVisual)
        {
        return;    
        }

    CHuiCanvasGc& canvasGc = iCanvasVisual->CanvasGc();
    canvasGc.ClearWithSkinBackground(aDisplayRect);    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHuiCanvasBackground::ClearWithColor(CHuiGc& /*aGc*/, const TRect& aDisplayRect)
    {    
    if (!iCanvasVisual)
        {
        return;    
        }

    CHuiCanvasGc& canvasGc = iCanvasVisual->CanvasGc();
            
    canvasGc.SetPenColor(iBackgroundColor);
    canvasGc.SetOpacity(TReal32(iBackgroundColor.Alpha()) / 255.f);    
    canvasGc.Clear(aDisplayRect);    
    }