/*
* 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 "HgIndicatorManager.h"

#include "HgConstants.h"
#include <ganes/HgItem.h>

#include <AknIconUtils.h>
#include <avkon.mbg>
#include <AknsDrawUtils.h>
#include <gulicon.h>
#include <AknUtils.h>
#include <ganes.mbg>
#include <AknLayout2ScalableDef.h>


CHgIndicatorManager* CHgIndicatorManager::NewL()
    {
    CHgIndicatorManager* self = new (ELeave) CHgIndicatorManager;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

CHgIndicatorManager::~CHgIndicatorManager()
    {
    delete iDrmIcon;
    delete iDrmExpIcon;
    delete iVideoIcon;
    delete iPlaybackIndicatorIcon;
    delete iMmcIcon;
    delete iMarkIcon;
    delete iPauseIndicatorIcon;
    delete iBrokenPlaylistIcon;
    delete iBrokenTrackIcon; 
    delete iCorruptedTrackIcon;
    delete iMassStorageIcon;
    delete iNewVideoIcon;
    delete iPhoneStorageIcon;
    delete iNewPodcastIcon;
    delete iPlayedPodcastIcon;
    delete iCompletelyPlayedPodcastIcon;
    delete iMoveUpIcon;
    delete iMoveDownIcon;
    delete iMoveUpDownIcon;
    }

void CHgIndicatorManager::InitIndicatorsL( const TSize& aIndicatorSize )
    {
    // Non-Skinned icons
    // Broken Playlist icon
    InitIconL( iBrokenPlaylistIcon, 
            EMbmGanesQgn_graf_mup_lst_brokenplayl, 
            EMbmGanesQgn_graf_mup_lst_brokenplayl_mask, 
            aIndicatorSize );
    
    // Broken track icon
    InitIconL( iBrokenTrackIcon, 
            EMbmGanesQgn_graf_mup_lst_brokentrack, 
            EMbmGanesQgn_graf_mup_lst_brokentrack_mask, 
            aIndicatorSize );
    
    // Corrupted track icon
    InitIconL( iCorruptedTrackIcon, 
            EMbmGanesQgn_graf_mup_lst_corrupttrack, 
            EMbmGanesQgn_graf_mup_lst_corrupttrack_mask, 
            aIndicatorSize );
    
    // New podcast icon 
    InitIconL( iNewPodcastIcon, 
            EMbmGanesQgn_graf_mup_lst_pdc_new, 
            EMbmGanesQgn_graf_mup_lst_pdc_new_mask, 
            aIndicatorSize );
    
    // Played podcast icon 
    InitIconL( iPlayedPodcastIcon, 
            EMbmGanesQgn_graf_mup_lst_pdc_partplay, 
            EMbmGanesQgn_graf_mup_lst_pdc_partplay_mask, 
            aIndicatorSize );

    // Completely played podcast icon 
    InitIconL( iCompletelyPlayedPodcastIcon, 
            EMbmGanesQgn_graf_mup_lst_pdc_compplay, 
            EMbmGanesQgn_graf_mup_lst_pdc_compplay_mask, 
            aIndicatorSize );

    // Video icon
    InitIconL( iVideoIcon,
            EMbmGanesQgn_indi_media_thumbnail, 
            EMbmGanesQgn_indi_media_thumbnail_mask, 
            aIndicatorSize );

    // Skinned icons
    // Mark icon
    InitIconL( iMarkIcon, KAknsIIDQgnPropSubMarked, 
            EMbmGanesQgn_prop_sub_marked, 
            EMbmGanesQgn_prop_sub_marked_mask, 
            aIndicatorSize );

    // DRM valid icon
    InitIconL( iDrmIcon, KAknsIIDQgnPropDrmRightsValidSuper, 
            EMbmGanesQgn_prop_drm_rights_valid_super, 
            EMbmGanesQgn_prop_drm_rights_valid_super_mask, 
            aIndicatorSize );
    
    // DRM expired icon
    InitIconL( iDrmExpIcon, KAknsIIDQgnPropDrmRightsExpSuper, 
            EMbmGanesQgn_prop_drm_rights_exp_super, 
            EMbmGanesQgn_prop_drm_rights_exp_super_mask, 
            aIndicatorSize );
    
    // Playback icon
    InitIconL( iPlaybackIndicatorIcon, KAknsIIDQgnIndiMupPlay, 
            EMbmGanesQgn_indi_mup_play, 
            EMbmGanesQgn_indi_mup_play_mask, 
            aIndicatorSize );
    
    // Pause icon
    InitIconL( iPauseIndicatorIcon, KAknsIIDQgnIndiMupPause, 
            EMbmGanesQgn_indi_mup_pause, 
            EMbmGanesQgn_indi_mup_pause_mask, 
            aIndicatorSize );
    
    // New Video icon
    InitIconL( iNewVideoIcon, KAknsIIDQgnPropFmgrFileVideo, 
            EMbmGanesQgn_prop_fmgr_file_video, 
            EMbmGanesQgn_prop_fmgr_file_video_mask, 
            aIndicatorSize );
    
    // Phone memory icon
    InitIconL( iPhoneStorageIcon, KAknsIIDQgnPropPhoneMemc, 
            EMbmGanesQgn_prop_phone_memc, 
            EMbmGanesQgn_prop_phone_memc_mask, 
            aIndicatorSize );

    // MMC memory icon
    InitIconL( iMmcIcon, KAknsIIDQgnPropMmcMemc, 
            EMbmGanesQgn_prop_mmc_memc, 
            EMbmGanesQgn_prop_mmc_memc_mask, 
            aIndicatorSize );
    
    // Mass memory icon
    InitIconL( iMassStorageIcon, KAknsIIDQgnPropFmgrMsSmall, 
            EMbmGanesQgn_prop_fmgr_ms_small, 
            EMbmGanesQgn_prop_fmgr_ms_small_mask, 
            aIndicatorSize );

    // Move up icon
    InitIconL( iMoveUpIcon, KAknsIIDQgnGrafMupAdtlReorderUp, 
            EMbmGanesQgn_graf_mup_adtl_reorder_up, 
            EMbmGanesQgn_graf_mup_adtl_reorder_up_mask, 
            aIndicatorSize );
    
    // Move down icon
    InitIconL( iMoveDownIcon, KAknsIIDQgnGrafMupAdtlReorderDown, 
            EMbmGanesQgn_graf_mup_adtl_reorder_down, 
            EMbmGanesQgn_graf_mup_adtl_reorder_down_mask, 
            aIndicatorSize );
    
    // Move updown icon
    InitIconL( iMoveUpDownIcon, KAknsIIDQgnGrafMupAdtlReorderUpdown, 
            EMbmGanesQgn_graf_mup_adtl_reorder_updown, 
            EMbmGanesQgn_graf_mup_adtl_reorder_updown_mask, 
            aIndicatorSize );
    }

void CHgIndicatorManager::DrawIndicators( 
        CWindowGc& aGc,
        const TRect& aRect,
        TInt aFlags, 
        TAknWindowComponentLayout aFirstIndicatorLayout, 
        TAknWindowComponentLayout aSecondIndicatorLayout 
        ) const
    {
    TAknLayoutRect secondIndicator;
    secondIndicator.LayoutRect(aRect, aSecondIndicatorLayout);

    TAknLayoutRect firstIndicator;
    firstIndicator.LayoutRect(aRect, aFirstIndicatorLayout);
    
    TAknLayoutRect rect = secondIndicator;
    TBool memIndicator = EFalse;
    TInt indicatorsDrawn = 0;
    
    if( aFlags & CHgItem::EHgItemFlagMarked )
        {
        rect.DrawImage(aGc, iMarkIcon->Bitmap(), iMarkIcon->Mask());
        ++indicatorsDrawn;
        rect = firstIndicator;
        }
    
    if( DrawIndicator(aGc, rect, aFlags, memIndicator) )
        {
        ++indicatorsDrawn;
        rect = firstIndicator;
        }
    
    if( indicatorsDrawn == 1 && !memIndicator )
        {
        if( aFlags & CHgItem::EHgItemFlagsMmc )
            {
            rect.DrawImage(aGc, iMmcIcon->Bitmap(), iMmcIcon->Mask() );        
            }
        else if( aFlags & CHgItem::EHgItemFlagsMassStorageIndicator )
            {
            rect.DrawImage(aGc, iMassStorageIcon->Bitmap(), iMassStorageIcon->Mask() );        
            }
        else if( aFlags & CHgItem::EHgItemFlagsPhoneStorageIndicator )
            {
            rect.DrawImage(aGc, iPhoneStorageIcon->Bitmap(), iPhoneStorageIcon->Mask() );        
            }
        }
    
    }

TBool CHgIndicatorManager::DrawIndicator( 
        CWindowGc& aGc,
        TAknLayoutRect& aRect,
        TInt aFlags,
        TBool& aMemIndicator 
        ) const
    {
    TBool ret = EFalse;
    
    if( aFlags & CHgItem::EHgItemFlagsPlaybackIndicator )
        {
        aRect.DrawImage(aGc, iPlaybackIndicatorIcon->Bitmap(), iPlaybackIndicatorIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsPauseIndicator )
        {
        aRect.DrawImage(aGc, iPauseIndicatorIcon->Bitmap(), iPauseIndicatorIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsDrmRightsValid )
        {
        aRect.DrawImage(aGc, iDrmIcon->Bitmap(), iDrmIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsDrmRightsExpired )
        {
        aRect.DrawImage(aGc, iDrmExpIcon->Bitmap(), iDrmExpIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsVideo )
        {
        aRect.DrawImage(aGc, iVideoIcon->Bitmap(), iVideoIcon->Mask() ); 
        ret = ETrue;
        }    
    else if( aFlags & CHgItem::EHgItemFlagsBrokenPlaylistIndicator )
        {
        aRect.DrawImage(aGc, iBrokenPlaylistIcon->Bitmap(), iBrokenPlaylistIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsBrokenTrackIndicator )
        {
        aRect.DrawImage(aGc, iBrokenTrackIcon->Bitmap(), iBrokenTrackIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsCorruptedTrackIndicator )
        {
        aRect.DrawImage(aGc, iCorruptedTrackIcon->Bitmap(), iCorruptedTrackIcon->Mask() ); 
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsNewVideoIndicator )
        {
        aRect.DrawImage(aGc, iNewVideoIcon->Bitmap(), iNewVideoIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsNewPodcastIndicator )
        {
        aRect.DrawImage(aGc, iNewPodcastIcon->Bitmap(), iNewPodcastIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsPlayedPodcastIndicator )
        {
        aRect.DrawImage(aGc, iPlayedPodcastIcon->Bitmap(), iPlayedPodcastIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsCompletelyPlayedPodcastIndicator )
        {
        aRect.DrawImage(aGc, iCompletelyPlayedPodcastIcon->Bitmap(), iCompletelyPlayedPodcastIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsMoveUpIndicator )
        {
        aRect.DrawImage(aGc, iMoveUpIcon->Bitmap(), iMoveUpIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsMoveDownIndicator )
        {
        aRect.DrawImage(aGc, iMoveDownIcon->Bitmap(), iMoveDownIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsMoveUpDownIndicator )
        {
        aRect.DrawImage(aGc, iMoveUpDownIcon->Bitmap(), iMoveUpDownIcon->Mask() );         
        ret = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsMmc )
        {
        aRect.DrawImage(aGc, iMmcIcon->Bitmap(), iMmcIcon->Mask() ); 
        ret = ETrue;
        aMemIndicator = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsMassStorageIndicator )
        {
        aRect.DrawImage(aGc, iMassStorageIcon->Bitmap(), iMassStorageIcon->Mask() );
        ret = ETrue;
        aMemIndicator = ETrue;
        }
    else if( aFlags & CHgItem::EHgItemFlagsPhoneStorageIndicator )
        {
        aRect.DrawImage(aGc, iPhoneStorageIcon->Bitmap(), iPhoneStorageIcon->Mask() );
        ret = ETrue;
        aMemIndicator = ETrue;
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CHgIndicatorManager::InitIconL()
// -----------------------------------------------------------------------------
//
void CHgIndicatorManager::InitIconL( CGulIcon*& aIcon,
                                TInt aIconIndex,
                                TInt aMaskIndex,
                                TSize aSize )
    {
    if( !aIcon )
        {
        CFbsBitmap* bitmap, *mask;
        AknIconUtils::CreateIconL( 
                bitmap, 
                mask, 
                KGanesMif, 
                aIconIndex, 
                aMaskIndex );
        aIcon = CGulIcon::NewL(bitmap, mask);
        }

    AknIconUtils::SetSize(aIcon->Bitmap(), aSize);        
    }

// -----------------------------------------------------------------------------
// CHgIndicatorManager::InitIconL()
// -----------------------------------------------------------------------------
//
void CHgIndicatorManager::InitIconL( CGulIcon*& aIcon,
                                const TAknsItemID& aItemId,
                                TInt aIconIndex,
                                TInt aMaskIndex,
                                TSize aSize )
    {
    if( !aIcon )
        {
        aIcon = AknsUtils::CreateGulIconL( 
                AknsUtils::SkinInstance(), 
                aItemId, 
                KGanesMif, 
                aIconIndex, 
                aMaskIndex );
        }

    AknIconUtils::SetSize(aIcon->Bitmap(), aSize);        
    }

// -----------------------------------------------------------------------------
// CHgIndicatorManager::InitIconL()
// -----------------------------------------------------------------------------
//
void CHgIndicatorManager::InitColorIconL( CGulIcon*& aIcon,
                                const TAknsItemID& aItemId,
                                TInt aIconIndex,
                                TInt aMaskIndex,
                                TSize aSize )
    {
    if( !aIcon )
        {
        TRgb defaultColour( KRgbWhite );
        MAknsSkinInstance* skin = AknsUtils::SkinInstance();
        
        AknsUtils::GetCachedColor( skin,
                defaultColour,
                KAknsIIDQsnIconColors,
                EAknsCIQsnIconColorsCG13 );
        
        CFbsBitmap *bitmap,*mask;
        AknsUtils::CreateColorIconL( 
                skin, 
                aItemId, 
                KAknsIIDQsnIconColors,
                EAknsCIQsnIconColorsCG13,
                bitmap, 
                mask,
                KGanesMif, 
                aIconIndex, 
                aMaskIndex,
                defaultColour );
        
        aIcon = CGulIcon::NewL(bitmap, mask);
        }

    AknIconUtils::SetSize(aIcon->Bitmap(), aSize);        
    }

TInt CHgIndicatorManager::CountIndicators( TInt aFlags )
    {
    TInt count = 0;
    aFlags &= (~CHgItem::EHgItemFlagsIconOverlayIndicator); // overlayindicator not counted
    while(aFlags)
        {
        count += aFlags & 0x1;
        aFlags = aFlags >> 1;
        }
    return count > KMaxNumberOfTitleIndicators ? KMaxNumberOfTitleIndicators : count;
    }

CHgIndicatorManager::CHgIndicatorManager()
    {
    
    }

void CHgIndicatorManager::ConstructL()
    {
    
    }
