/*

* Copyright (c) 2006-2007 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:   Implementation of CHuiTexture.

*

*/

#include "uiacceltk/HuiTexture.h"  // Class definition

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"

#include "HuiRenderSurface.h"

#include "uiacceltk/HuiProbe.h"

#include "uiacceltk/HuiTextureProcessor.h"

#include <e32math.h>

const TInt KHuiTextureDefaultPriority = 1; // currenly just != 0

// placeholder

EXPORT_C MHuiTexture::~MHuiTexture()

    {

    }

EXPORT_C CHuiTexture* CHuiTexture::NewL(const THuiTextureHandle* aExistingTexture)

    {

    return CHuiStatic::Renderer().CreateTextureL(aExistingTexture);

    }

EXPORT_C CHuiTexture* CHuiTexture::NewLC(const THuiTextureHandle* aExistingTexture)

    {

    CHuiTexture* self = CHuiTexture::NewL(aExistingTexture);

    CleanupStack::PushL(self);

    return self;

    }

EXPORT_C CHuiTexture::CHuiTexture()

    {

    HUI_PROBE_ASSOCIATE_WITH_CURRENT_SESSION

    HUI_PROBE_REPORT_CONSTRUCTED

    }

EXPORT_C void CHuiTexture::BaseConstructL()

    {

    // No name by default.

    SetImageFileNameL(_L(""));

    HUI_DEBUG(_L("CHuiTexture::BaseConstructL() - Auto-appending to texture manager."));

    // Make the texture automatically owned by the texture manager.

    CHuiStatic::Env().TextureManager().AppendTextureL(this);

    iInternalState |= EHuiTextureFlagAddedToTManager;

    iPriority  = KHuiTextureDefaultPriority;

    }

EXPORT_C CHuiTexture::~CHuiTexture()

    {

    iContentObservers.Close();

    HUI_DEBUG(_L("CHuiTexture::~CHuiTexture() - Auto-removing from texture manager."));

    // Remove the texture automatically from the texture manager.

    if (iInternalState & EHuiTextureFlagAddedToTManager)

        {

        CHuiStatic::Env().TextureManager().RemoveTexture(*this);

        }

    // NOTE: Do NOT call Reset, or SegSegmentCount(0) from

    // here since they have pure virtual method calls,

    // which won't work anymore :(

    iSegments.Close();

    delete iImageFileName;

    iImageFileName = NULL;

    iPlaceholder = NULL;

    iPreferredSizes.Close();

    // delete all created shadows

    ResetShadows();

    iShadows.Close();

    HUI_PROBE_REPORT_DESTRUCTED

    }

EXPORT_C MHuiSegmentedTexture* CHuiTexture::SegmentedTexture()

    {

    return this;

    }

EXPORT_C MHuiShadowedTexture* CHuiTexture::ShadowedTexture()

    {

    return this;

    }

EXPORT_C const MHuiSegmentedTexture* CHuiTexture::SegmentedTexture() const

    {

    return this;

    }

EXPORT_C const MHuiShadowedTexture* CHuiTexture::ShadowedTexture() const

    {

    return this;

    }

TBool CHuiTexture::GetShadowTexture(

        THuiTextureHandle& aHandle, 

        TInt aBlurDimension ) const

    {

    for ( TInt i = 0 ; i < iShadows.Count() ; i++ )

        {

        if ( iShadows[i].iBlurDimension == aBlurDimension )

            {

            aHandle = iShadows[i].iShadowTexture->Handle();

            return ETrue;

            }

        }

    return EFalse;

    }

void CHuiTexture::CreateShadowTextureL(

        TInt aBlurDimension,

        THuiShadowStyle aStyle )

    {

    // check if the shadow already exists

        {

        THuiTextureHandle dummy;

        if ( GetShadowTexture( dummy, aBlurDimension ) )

            {

            return;

            }   

        }

    // shadow not found -> generate one.

    CHuiTexture* newShadowTexture = CHuiTexture::NewL();

    CHuiStatic::Env().TextureManager().RemoveTexture(*newShadowTexture);

    newShadowTexture->iInternalState &= ~EHuiTextureFlagAddedToTManager;

    CleanupStack::PushL( newShadowTexture );

    newShadowTexture->SetSegmentCountL(1);

    // blur

    CHuiTextureProcessor& proc = CHuiStatic::Env().TextureManager().Processor();

    THuiTextureHandle shadowHandle = newShadowTexture->Handle();

    switch(aStyle)

        {

        case EHuiTextureShadowStyleIcon:

            proc.BlurSegmentedL(*this, shadowHandle, TSize(Size().iWidth/2, Size().iHeight/2), aBlurDimension,

                CHuiTextureProcessor::EBlurFlagWhite |

                CHuiTextureProcessor::EBlurFlagAlpha |

                CHuiTextureProcessor::EBlurFlagExpandEdges);

            break;

        case EHuiTextureShadowStyleRasterizedText:

            proc.BlurSegmentedL(*this, shadowHandle, TSize(Size().iWidth/*/2*/, Size().iHeight/*/2*/), aBlurDimension,

                CHuiTextureProcessor::EBlurFlagWhite |

                CHuiTextureProcessor::EBlurFlagAlpha |

                CHuiTextureProcessor::EBlurFlagExpandEdges);

            break;

        default:

            break;

        }   

    newShadowTexture->SetSegmentSize(0,shadowHandle.iSize );

    newShadowTexture->SetSegmentTextureSize(0,shadowHandle.iTextureSize );    

    // create item on the array

    TShadowData newData;

    newData.iShadowTexture = newShadowTexture;

    newData.iBlurDimension = aBlurDimension;

    iShadows.AppendL( newData );

    CleanupStack::Pop( newShadowTexture );

    }

EXPORT_C void CHuiTexture::EnableShadow(TBool aEnable)

    {

    if(aEnable)

    	{

    	iInternalState |= EHuiTextureFlagShadowEnabled;

    	}

    else

    	{

    	iInternalState &= ~EHuiTextureFlagShadowEnabled;

    	// delete all created shadows

    	ResetShadows();

    	}

    }

EXPORT_C TBool CHuiTexture::IsShadowEnabled() const

    {

    return ((iInternalState & EHuiTextureFlagShadowEnabled) != 0);

    }

EXPORT_C void CHuiTexture::SetShadowStyle(THuiShadowStyle aShadowStyle)

    {

    iShadowStyle = aShadowStyle;

    }

EXPORT_C THuiShadowStyle CHuiTexture::ShadowStyle() const

    {

    return iShadowStyle;

    }

EXPORT_C TBool CHuiTexture::GetShadowTexture(THuiTextureHandle& aHandle) const

    {

    // Return the first shadow if generated

    if ( iShadows.Count() )

        {

        aHandle = iShadows[0].iShadowTexture->Handle();

        return ETrue;

        }

    return EFalse;

    }

EXPORT_C void CHuiTexture::SetSegmentCountL(TInt aSegmentCount)

    {

    // delete old segments (if needed)

    TInt count = iSegments.Count();

    while(count > aSegmentCount)

        {

        count--;

        HUI_DEBUG1(_L("CHuiTexture::SetSegmentCount - Deallocating segment %i"), count);

        // Deallocate resources associated with segment

        // NOTE: call to pure virtual method, will not work from the

        // destructor of this class..

        ResetSegment(count);

        iSegments.Remove(count);

        }

    // add new texture segments (if needed)

    while(count < aSegmentCount)

        {

        TSegment seg;

        User::LeaveIfError(iSegments.Append(seg));

        HUI_DEBUG1(_L("CHuiTexture::SetSegmentCount - Creating segment %i"), count);

        // Create initial segment with texture name etc.

        InitSegmentL(count);

        count++;

        }

    }

EXPORT_C TSize CHuiTexture::Size() const

    {

    if(iPlaceholder)

        {

        return iPlaceholder->Size();

        }

    return iSize;

    }

EXPORT_C TInt CHuiTexture::SegmentCount() const

    {

    if(iPlaceholder)

        {

        return iPlaceholder->SegmentCount();

        }

    return iSegments.Count();

    }

EXPORT_C TUint CHuiTexture::SegmentName(TInt aSegment) const

    {

    ASSERT(aSegment < SegmentCount());

    if(iPlaceholder)

        {

        return iPlaceholder->SegmentName(aSegment);

        }

    return iSegments[aSegment].iName;

    }

EXPORT_C TSize CHuiTexture::SegmentSize(TInt aSegment) const

    {

    ASSERT(aSegment < SegmentCount());

    if(iPlaceholder)

        {

        return iPlaceholder->SegmentSize(aSegment);

        }

    return iSegments[aSegment].iSize;

    }

EXPORT_C TSize CHuiTexture::SegmentTextureSize(TInt aSegment) const

    {

    ASSERT(aSegment < SegmentCount());

    if(iPlaceholder)

        {

        return iPlaceholder->SegmentTextureSize(aSegment);

        }

    return iSegments[aSegment].iTextureSize;

    }

EXPORT_C TPoint CHuiTexture::SegmentOffset(TInt aSegment) const

    {

    ASSERT(aSegment < SegmentCount());

    if(iPlaceholder)

        {

        return iPlaceholder->SegmentOffset(aSegment);

        }

    return iSegments[aSegment].iOffset;

    }

EXPORT_C void CHuiTexture::SetSize(const TSize& aSize)

    {

    // if there are multiple

    // segments already defined we have to recalculate (rescale)

    // the logical sizes and offsets for the individual segments

    // to match the new logical size

    if (SegmentCount()>0 && iSize.iWidth > 0 && iSize.iHeight > 0)

        {

        for (TInt s = 0; s < SegmentCount(); s++)

            {

            TSize oldSize(SegmentSize(s));

            TSize newSize(oldSize.iWidth * aSize.iWidth / iSize.iWidth,

                          oldSize.iHeight * aSize.iHeight / iSize.iHeight);

            TPoint oldOffset(SegmentOffset(s));

            TPoint newOffset(oldOffset.iX * aSize.iWidth / iSize.iWidth,

                             oldOffset.iY * aSize.iHeight / iSize.iHeight);

            SetSegmentSize(s, newSize);

            SetSegmentOffset(s, newOffset);

            }

        }

    // assign new logical size

    iSize = aSize;

    }

EXPORT_C void CHuiTexture::SetSegmentName(TInt aSegment, TUint aName)

    {

    ASSERT(aSegment < SegmentCount());

    iSegments[aSegment].iName = aName;

    }

EXPORT_C void CHuiTexture::SetSegmentSize(TInt aSegment, const TSize& aSegmentSize)

    {

    ASSERT(aSegment < SegmentCount());

    iSegments[aSegment].iSize = aSegmentSize;

    }

EXPORT_C void CHuiTexture::SetSegmentTextureSize(TInt aSegment, const TSize& aSegmentTextureSize)

    {

    ASSERT(aSegment < SegmentCount());

    iSegments[aSegment].iTextureSize = aSegmentTextureSize;

    }

EXPORT_C void CHuiTexture::SetSegmentOffset(TInt aSegment, const TPoint& aOffset)

    {

    ASSERT(aSegment < SegmentCount());

    iSegments[aSegment].iOffset = aOffset;

    }

EXPORT_C void CHuiTexture::SetSkinContent(TBool aSkinContent)

    {

    if(aSkinContent)

    	{

    	iInternalState |= EHuiTextureFlagSkinContent;

    	}

    else

    	{

    	iInternalState &= ~EHuiTextureFlagSkinContent;

    	}    

    }

EXPORT_C TBool CHuiTexture::IsSkinContent() const

    {

    return ((iInternalState & EHuiTextureFlagSkinContent) != 0);    

    }

EXPORT_C void CHuiTexture::Reset()

    {

    EnableShadow(EFalse); // deletes the shadow textures

    RemoveAllSegments();

    iActiveSegment = 0;

    iSize = TSize(0, 0);

    iPlaceholder = NULL;

    // We're not resetting the texture name here.

    // this is intentional since the name may be

    // used to restore the texture content later on

    }

EXPORT_C void CHuiTexture::ResetShadows()

    {

    while ( iShadows.Count() )

        {

        delete iShadows[iShadows.Count()-1].iShadowTexture;

        iShadows.Remove( iShadows.Count()-1);

        }

    }

EXPORT_C const TDesC& CHuiTexture::ImageFileName() const

    {

    return *iImageFileName;

    }

EXPORT_C TBool CHuiTexture::HasContent() const

    {

    return (SegmentCount() > 0);

    }

EXPORT_C TInt CHuiTexture::ClearL(const TSize& aSize, const TRgb& aColor)

    {

    // Always assign new logical size

    SetSize(aSize);

    // if there are no segments, configure them based on the given size!

    ASSERT(SegmentCount() != 0 || (aSize.iWidth > 0 && aSize.iHeight > 0));

    if(SegmentCount() == 0)

        {

        SetupSegmentsL(aSize, aSize);

        }

    // clear all segments..

    for(TInt segment = 0; segment < SegmentCount(); ++segment)

        {

        TRAPD(err, SegmentClearL(segment, EFalse, aColor, 0) );

        if(err == KErrNoMemory)

            {

            HUI_DEBUG2(_L("CHuiTexture::Clear() - Out of memory trying to clear segment %i from \"%S\"."),

                       segment, &ImageFileName());

            return err;

            }

        else if(err != KErrNone)

            {

            HUI_DEBUG1(_L("CHuiTexture::Clear() - SegmentClearL failed with error code %i."), err);

            return err;

            }

        else

            {

            // for PC lint

            }

        }

    // succeeded!

    return KErrNone;

    }

EXPORT_C TInt CHuiTexture::ClearWithAlphaL(const TSize& aSize, const TRgb& aColor,

        TUint8 aAlpha)

    {

    if(Size()==TSize(0,0))

        {

        SetSize(aSize);

        }

    // if there are no segments, configure them based on the given size!

    ASSERT(SegmentCount() != 0 || (aSize.iWidth > 0 && aSize.iHeight > 0));

    if(SegmentCount() == 0)

        {

        SetupSegmentsL(aSize, aSize);

        }

    // clear all segments..

    for (TInt segment = 0; segment < SegmentCount(); ++segment)

        {

        TRAPD(err, SegmentClearL(segment, ETrue, aColor, aAlpha) );

        if(err == KErrNoMemory)

            {

            HUI_DEBUG2(_L("CHuiTexture::ClearWithAlpha() - Out of memory trying to clear segment %i from \"%S\"."),

                       segment, &ImageFileName());

            return err;

            }

        else if(err != KErrNone)

            {

            HUI_DEBUG1(_L("CHuiTexture::ClearWithAlpha() - SegmentClearL failed with error code %i."), err);

            return err;

            }

        else

            {

            // for PC lint

            }

        }

    // succeeded!

    return KErrNone;

    }

/**

 * Set segment data.

 */

EXPORT_C void CHuiTexture::SetSegment(TInt aSegment,