MCL/sf/app/homescreen: comparison idlehomescreen/widgetmanager/src/wmimageconverter.cpp

equal deleted inserted replaced

-:5315654608de
+:08c6ee43b396
 CWmImageConverter::~CWmImageConverter()
 {
 Cancel();
 delete iImageDecoder;
 iFs.Close();
-if (iBitmap)
+if ( iBitmap )
 {
 delete iBitmap;
 iBitmap = NULL;
 }
-if (iMask)
+if ( iMask )
 {
 delete iMask;
 iMask = NULL;
 }
 delete iScaler;
+}
+// ---------------------------------------------------------
+// CWmImageConverter::HandleIconString
+// ---------------------------------------------------------
+//
+TInt CWmImageConverter::HandleIconString(
+TInt aWidth, TInt aHeight,
+const TDesC& aIconStr )
+{
+TInt err( KErrNone );
+TRAP( err, HandleIconStringL( aWidth, aHeight, aIconStr ); );
+if ( KErrNone != err )
+{
+iState = EFailed;
+if ( iBitmap )
+{
+delete iBitmap;
+iBitmap = NULL;
+}
+if ( iMask )
+{
+delete iMask;
+iMask = NULL;
+}
+}
+return err;
 }
 // ---------------------------------------------------------
 // CWmImageConverter::HandleIconStringL
 // ---------------------------------------------------------
 //
 void CWmImageConverter::HandleIconStringL(
 TInt aWidth, TInt aHeight,
 const TDesC& aIconStr )
 {
+iConversionMethod = EUnrecognized;
+iState = EDecoding;
 if ( aIconStr.Length() )
 {
 TAknsItemID skinItemId;
 skinItemId.iMajor = 0;
 skinItemId.iMinor = 0;
 TInt bitmapId( KErrNotFound );
 TInt maskId( KErrNotFound );
 TUid appUid;
 iFilename = KNullDesC;
 iScaleNeeded = EFalse;
 iSize.SetSize( aWidth, aHeight );
 if ( ResolveSkinIdAndMifId(
 aIconStr, skinItemId, bitmapId, maskId, iFilename ) )
 {
 iConversionMethod = EImageIcon;
 CreateIconFromOtherL( aIconStr );
 }
 else
 {
-iConversionMethod = EUnrecognized;
 User::Leave( KErrArgument );
 }
+}
+else
+{
+User::Leave( KErrArgument );
 }
 }
 // ---------------------------------------------------------
 // CWmImageConverter::CreateIconFromUidL
 if ( size == iSize )
 {
 break;
 }
 }
 }
 CApaMaskedBitmap* maskedBmp = CApaMaskedBitmap::NewLC();
 User::LeaveIfError( lsSession.GetAppIcon( aUid, size, *maskedBmp ) );
 iBitmap = static_cast<CFbsBitmap*>( maskedBmp );  // ownership transfered
 iMask = new ( ELeave ) CFbsBitmap;
 CleanupStack::PopAndDestroy( &lsSession );
 // scale or notify
 if ( size == iSize )
 {
+iState = EIdle;
 iObserver->NotifyCompletion( KErrNone );
 }
 else
 {
 iScaleNeeded = ETrue;
 {
 err = AknIconUtils::SetSize( iMask , iSize, EAspectRatioNotPreserved );
 }
 // notify observer
+iState = EIdle;
 iObserver->NotifyCompletion( err );
 }
 else
 {
+iState = EIdle;
 User::Leave( KErrArgument );
 }
 }
 // ---------------------------------------------------------
 CleanupStack::Pop( bitmap );
 CleanupStack::PopAndDestroy( frameBuffer );
 iBitmap = bitmap;
 iMask = mask;
+iState = EIdle;
 iObserver->NotifyCompletion( KErrNone );
 }
 // ---------------------------------------------------------
 // CWmImageConverter::CheckSvgErrorL
 // CWmImageConverter::CreateIconFromOtherL
 // ---------------------------------------------------------
 //
 void CWmImageConverter::CreateIconFromOtherL( const TDesC& aFileName )
 {
-if ( IsActive() || iState != EIdle )
+if ( IsActive() )
 {
 User::Leave( KErrNotReady );
 }
 if ( iImageDecoder ) delete iImageDecoder; iImageDecoder = NULL;
 if ( size != iSize )
 {
 iScaleNeeded = ETrue;
 }
 // start conversion to bitmap
-iState = EDecoding;
 iImageDecoder->Convert( &iStatus, *iBitmap, *iMask );
 SetActive();
 }
 // ---------------------------------------------------------
 // CWmImageConverter::DoCancel
 // ---------------------------------------------------------
 //
 void CWmImageConverter::DoCancel()
 {
-if( iState == EDecoding )
+if( iState == EDecoding &&
-{
+iConversionMethod == EImageIcon )
-iImageDecoder->Cancel();
+{
+iImageDecoder->Cancel();
+iState = EIdle;
 if ( iObserver )
 {
 iObserver->NotifyCompletion( KErrCancel );
 }
 }
 else if( iState == EScalingBitmap ||
 iState == EScalingMask )
 {
 iScaler->Cancel();
+iState = EIdle;
 if ( iObserver )
 {
 iObserver->NotifyCompletion( KErrCancel );
 }
 }
 else
 {
 // State is EIdle, do nothing
 }
-iState = EIdle;
 iScaleNeeded = EFalse;
 }
 // ---------------------------------------------------------
 // CWmImageConverter::RunL
 {
 if ( !IsActive() &&
 iBitmap &&
 ( iState == EDecoding || iState == EIdle ) )
 {
+iState = EScalingBitmap;
 // the maintain aspect ratio is by default set to true
 iScaler->Scale( &iStatus, *iBitmap, TSize( aWidth,aHeight ), EFalse );
-iState = EScalingBitmap;
 SetActive();
 }
 }
 // ---------------------------------------------------------
 {
 if ( !IsActive() &&
 iState == EScalingBitmap &&
 iMask )
 {
+iState = EScalingMask;
 // the maintain aspect ratio is by default set to true
 iScaler->Scale( &iStatus, *iMask, TSize(aWidth,aHeight), EFalse );
-iState = EScalingMask;
 SetActive();
 }
 }
 // ---------------------------------------------------------
 // Syntax: uid(0x12345678)
 TInt error = KErrNotFound;
 TInt pos = aPath.FindF( KUid );
 if( pos == 0 )
 {
-// Skip skin token
+// Skip uid token
 pos += KUid().Length();
 // Initialize lexer
 TLex lex( aPath.Mid( pos ) );
+lex.SkipSpaceAndMark();
 // Check left parenthesis
 if ( lex.Get() == KLeftParenthesis )
 {
-lex.SkipSpaceAndMark();
+error = ParseNextUint( lex, (TUint&)aUid.iUid );
-lex.SkipCharacters();
-TPtrC mtoken = lex.MarkedToken();
-pos = mtoken.FindF( KHexPrefix );
-if ( pos == 0 )
-{
-TLex lex( mtoken.Mid( KHexPrefix().Length() ) );
-TUint id = 0;
-error = lex.Val( id, EHex );
-aUid = TUid::Uid( (TInt)id );
-}
-else
-{
-TInt id( 0 );
-error = lex.Val( id );
-aUid.iUid = id;
-}
 }
 }
 return (error == KErrNone );
 }
 // Skip skin token
 pos += KSkin().Length();
 // Initialize lexer
 TLex lex( aPath.Mid( pos ) );
+lex.SkipSpaceAndMark();
-lex.SkipSpaceAndMark();
 // Check left parenthesis
 if ( lex.Get() == KLeftParenthesis )
 {
-pos++;
+TUint majorId = 0;
-TLex lex( aPath.Mid( pos ) );
+TUint minorId = 0;
-lex.SkipSpaceAndMark();
+error = ParseNextUint( lex, majorId );
+error |= ParseNextUint( lex, minorId );
-TPtrC mtoken = lex.MarkedToken();
+aItemId.Set( majorId, minorId );
-pos = mtoken.FindF( KHexPrefix );
-if ( pos == 0 )
-{
-TUint majorId( 0 );
-TUint minorId( 0 );
-lex.Assign( mtoken.Mid( KHexPrefix().Length() ) );
-error = lex.Val( majorId, EHex );
-lex.SkipSpace();
-lex.SkipAndMark( KHexPrefix().Length() );
-error |= lex.Val( minorId, EHex );
-aItemId.Set( majorId, minorId );
-}
-else
-{
-TInt majorId(0);
-TInt minorId(0);
-error = lex.Val( majorId );
-lex.SkipSpace();
-error |= lex.Val( minorId );
-aItemId.Set( majorId, minorId );
-}
 }
 }
 return (error == KErrNone );
 }
 {
 // Skip mif token
 pos += KMif().Length();
 // Initialize lexer
 TLex lex( aPath.Mid( pos ) );
+lex.SkipSpaceAndMark();
 // Check left parenthesis
 if ( lex.Get() == KLeftParenthesis )
 {
 lex.SkipSpaceAndMark();
 lex.SkipCharacters();
 // Resolve MifFile name
 aFileName.Copy(lex.MarkedToken());
 if( aFileName.Length()!= 0)
 {
-// Resolve bitmap id
+TUint bitmap, mask;
-lex.SkipSpace();
+error = ParseNextUint( lex, bitmap );
-error = lex.Val( aBitmapId );
+ParseNextUint( lex, mask ); // mask is not mandatory
+aBitmapId = bitmap;
-// Resolve mask id
+aMaskId = mask;
-// dont return error if it is not found, that is ok
-lex.SkipSpace();
-lex.Val( aMaskId );
-}
-else
-{
-error = KErrNotFound;
 }
 }
 }
-return (error == KErrNone );
+return ( error == KErrNone );
 }
 // ---------------------------------------------------------------------------
 // CWmImageConverter::ResolveSkinIdAndMifId
 // ---------------------------------------------------------------------------
 itemData->SetBitmap( NULL );
 mask = itemData->Mask();
 itemData->SetMask( NULL );
 CleanupStack::PopAndDestroy( itemData );
 }
 else
 {
 // look in imagetable
 CAknsImageTableItemData* iconData = NULL;
 TRAP( err, iconData = static_cast<CAknsImageTableItemData*>(
 skin->CreateUncachedItemDataL( aItemId, EAknsITImageTable ) ); );
 {
 err = AknIconUtils::SetSize( mask , iSize, EAspectRatioNotPreserved );
 }
 iBitmap = bitmap;
 iMask = mask;
-// notify observer
+iState = EIdle;
+// notify observer
 iObserver->NotifyCompletion( KErrNone );
 return;
 }
 else
 {
 bitmap = AknIconUtils::CreateIconL( *this, aBitmapId );
 }
 }
 else
 {
+iState = EIdle;
 User::Leave( KErrArgument );
 }
 iBitmap = bitmap;
 iMask = mask;
 TInt err = AknIconUtils::SetSize( iBitmap , iSize, EAspectRatioNotPreserved );
 if ( KErrNone == err )
 {
 err = AknIconUtils::SetSize( iMask , iSize, EAspectRatioNotPreserved );
 }
+iState = EIdle;
 // notify observer
 iObserver->NotifyCompletion( err );
 }
 // ---------------------------------------------------------------------------
+// CWmImageConverter::ParseNextUint()
+// ---------------------------------------------------------------------------
+//
+TInt CWmImageConverter::ParseNextUint( TLex& aLex, TUint& aValue )
+{
+TInt error = KErrNone;
+aLex.SkipSpaceAndMark();
+aLex.SkipCharacters();
+TPtrC mtoken = aLex.MarkedToken();
+TInt pos = mtoken.FindF( KHexPrefix );
+if ( pos == 0 )
+{
+		TLex innerLex( mtoken.Mid( KHexPrefix().Length() ) );
+error = innerLex.Val( aValue, EHex );
+}
+else
+{
+TLex innerLex( mtoken );
+error = innerLex.Val( aValue, EDecimal );
+}
+return error;
+}
+// ---------------------------------------------------------------------------
 // CWmImageConverter::SetLogoSize()
 // ---------------------------------------------------------------------------
 //
 void CWmImageConverter::SetLogoSize( const TSize& aSize )
 {
 // ---------------------------------------------------------------------------
 //
 void CWmImageConverter::RetrieveIconFileHandleL(
 RFile& aFile, const TIconFileType /*aType*/ )
 {
-	User::LeaveIfError( aFile.Open( iFs, iFilename, EFileShareAny ) );
+	TInt err = aFile.Open( iFs, iFilename,
+	        EFileRead | EFileShareReadersOnly );
+	if ( KErrNone != err )
+	    {
+iState = EIdle;
+User::Leave( err );
+	    }
 }
 // ---------------------------------------------------------------------------
 // CWmImageConverter::Finished
 // ---------------------------------------------------------------------------
 void CWmImageConverter::Finished()
 {
 // finishes using the icon file. No actions needed here.
 }
+// ---------------------------------------------------------------------------
+// CWmImageConverter::IsProcessing
+// ---------------------------------------------------------------------------
+//
+TBool CWmImageConverter::IsProcessing()
+{
+return ( ( ( iState != EIdle && iState != EFailed ) ||
+IsActive() ) ? ETrue : EFalse );
+}
 // End of file

changeset 2	08c6ee43b396
parent 1	5315654608de
child 4	4d54b72983ae