/*
* Copyright (c) 2009 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 FILES

#include "HgVgLabel.h"
#include "HgVgHelper.h"
#include "HgVgDrawBuffer.h"
#include "HgDrawUtils.h"

#include <ganes.mbg>
#include <AknIconUtils.h>
#include <avkon.mbg>
#include <AknsDrawUtils.h>
#include <touchfeedback.h>
#include <gulicon.h>
#include <AknUtils.h>
#include <layoutmetadata.cdl.h>
#include <AknLayout2ScalableDef.h>
#include <e32math.h>
#include <gulcolor.h>

#include <AknsDrawUtils.h>


// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CHgVgTitleRenderer::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHgVgLabel* CHgVgLabel::NewL(const TRect& aRect, const CFont* aFont, const TDesC& aText)
    {
    CHgVgLabel* self = new ( ELeave ) CHgVgLabel(aRect, aFont);
    CleanupStack::PushL (self );
    self->ConstructL(aText);
    CleanupStack::Pop ( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CHgVgTitleRenderer::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHgVgLabel::ConstructL (const TDesC& aText)
    {
    iText = aText.AllocL();
    
    iTextRenderer = CHgVgDrawBuffer::NewL(iRect.Size(), EGray2);
        
    iTextImage = vgCreateImage(VG_A_1, 
            iRect.Width(), iRect.Height(), 
            VG_IMAGE_QUALITY_NONANTIALIASED);
    
    if (iTextImage == VG_INVALID_HANDLE)
        {
        User::Leave(KErrNoMemory);
        }
        
    // get text color from skin
    if ( AknsUtils::AvkonSkinEnabled() )
        {
        // this does not modify color unless it gets a correct one
        // no real need to check errors
        AknsUtils::GetCachedColor( 
                AknsUtils::SkinInstance(),
                iTextColor,
                KAknsIIDQsnTextColors,
                EAknsCIQsnTextColorsCG6 );
        }
    
    if (iTextColor.Red() < 128)
        {
        iShadowColor = KRgbWhite;
        }
    else
        {
        iShadowColor = KRgbBlack;
        }
        
    }

// -----------------------------------------------------------------------------
// CHgVgTitleRenderer::CHgVgTitleRenderer()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CHgVgLabel::CHgVgLabel(const TRect& aRect, const CFont* aFont) : 
iRect(aRect),
iFont(aFont),
iTextColor(KRgbDarkGray),
iShadowColor(KRgbBlack),
iDirty(ETrue)
    {
    
    }
        
// -----------------------------------------------------------------------------
// CHgVgTitleRenderer::~CHgVgTitleRenderer()
// Destructor.
// -----------------------------------------------------------------------------
//
CHgVgLabel::~CHgVgLabel ( )
    {
    delete iText;
    delete iTextRenderer;    
    // then parent
    vgDestroyImage(iTextImage);
    }

// -----------------------------------------------------------------------------
// CHgVgLabel::SetText()
// -----------------------------------------------------------------------------
//
void CHgVgLabel::SetTextL(const TDesC& aText)
    {
    if (aText != *iText)
        {
        delete iText;
        iText = 0;
        iText = aText.AllocL();
        iDirty = ETrue;
        }
    }

// -----------------------------------------------------------------------------
// CHgVgLabel::SetFont()
// -----------------------------------------------------------------------------
//
void CHgVgLabel::SetFont(const CFont* aFont)
    {
    if (aFont != iFont)
        {
        iFont = aFont;
        iDirty = ETrue;
        }
    }

// -----------------------------------------------------------------------------
// CHgVgLabel::SetColor()
// -----------------------------------------------------------------------------
//
void CHgVgLabel::SetColor(const TRgb& aColor)
    {
    iTextColor = aColor;
    }

// -----------------------------------------------------------------------------
// CHgVgLabel::SetColor()
// -----------------------------------------------------------------------------
//
void CHgVgLabel::SetShadowColor(const TRgb& aColor)
    {
    iShadowColor = aColor;
    }

// -----------------------------------------------------------------------------
// CHgVgLabel::Draw()
// -----------------------------------------------------------------------------
//
void CHgVgLabel::Draw(const TRect& aWindowRect, TReal aAlpha)
    {
    if (iDirty)
        {
        Update();
        iDirty = EFalse;
        }
    
    TRgb color = iTextColor;
    color.SetAlpha(255.0f * aAlpha);
    TRgb shadowColor = iShadowColor;
    shadowColor.SetAlpha(255.0f * aAlpha);

    //HgVgHelper::DrawImageColorized(iTextImage, shadowColor, iRect.iTl+TPoint(1,1), aWindowRect);    
    HgVgHelper::DrawImageColorized(iTextImage, color, iRect.iTl, aWindowRect);    
    }

// -----------------------------------------------------------------------------
// CHgVgLabel::Update()
// -----------------------------------------------------------------------------
//
void CHgVgLabel::Update()
    {
    iTextRenderer->Clear(iRect.Size(), KRgbBlack);
/*    iTextRenderer->Gc().SetPenColor(KRgbWhite);    
        
    iTextRenderer->Gc().UseFont(iFont);
    iTextRenderer->Gc().DrawText(*iText, TPoint(
            iRect.Width() / 2 - iFont->TextWidthInPixels(*iText) / 2, 
            iFont->HeightInPixels()));
*/
    TAknLayoutText text;
            
    text.LayoutText(iParentRect, iLayout);
    text.DrawText(iTextRenderer->Gc(), *iText, ETrue, KRgbWhite);
    
    iTextRenderer->GetDrawBufferToVgImage(TRect(TPoint(0,0), iRect.Size()), 
            TPoint(0, 0), iTextImage, VG_A_1);    
    }


void CHgVgLabel::SetLayout(const TAknTextComponentLayout& aLayout, const TRect& aParentRect)
    {
    iLayout = aLayout;
    iLayout.Sett(0);
    iLayout.Setl(0);
    iParentRect = aParentRect;
    }

void CHgVgLabel::DrawEmptyText(const TRect& aClientRect, const TDesC& aText)
    {
    iTextRenderer->Clear(iRect.Size(), KRgbBlack);
    DrawEmptyListImpl_real(aClientRect, iTextRenderer->Gc(), aText, KRgbWhite);
    iTextRenderer->GetDrawBufferToVgImage(TRect(TPoint(0,0), iRect.Size()), 
            TPoint(0, 0), iTextImage, VG_A_1);
    iDirty = EFalse;
    Draw(aClientRect, 1.0f);
    }



// End of File