diff -r aecbbf00d063 -r d48ab3b357f1 uifw/ganes/src/HgIndicatorManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/ganes/src/HgIndicatorManager.cpp Wed Sep 01 12:16:19 2010 +0100 @@ -0,0 +1,444 @@ +/* +* 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 + +#include +#include +#include +#include +#include +#include +#include + + +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() + { + + }