/*
* Copyright (c) 2002 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: Pictograph drawer
*
*/
// INCLUDE FILES
#include <fbs.h>
#include <gdi.h>
#include <bitdev.h>
#include <mmfcontrollerpluginresolver.h> // For CleanupResetAndDestroyPushL
#include "BitmapBuilder.h"
#include "aknpictographconfig.h" // KBitmapDisplayMode, KMaskDisplayMode
// KBitmapTag, KMaskTag
// CONSTANTS
// The root is mapped to parent of dir AknPictograph
_LIT( KDefaultPath, "a:\\" );
// This should be carefully selected beacuse adding support
// for new height will need about 40 KB more
TUint KBufferSizeForHeaderGeneration = 300000;
// WINC platform - paths mapped directly in PC file system
// on EKA2 drive a: is mapped to the PC file system
_LIT( KConfigPathEpoc, "\\AknPictograph\\config\\" );
_LIT( KConfigFile, "picto%u.ini" );
_LIT( KGeneratedPathEpoc, "\\AknPictograph\\generated\\" );
// String for inserting in batch files
_LIT( KGeneratedPath, "..\\generated\\" );
_LIT( KBmconvFile, "bmconv%u.txt" );
_LIT( KMultiBitmapFile, "AknPictograph_multi%u.mbm" );
_LIT( KBitmapFile, "AknPictograph%u.mbm" );
_LIT( KMaskFile, "AknPictographMask%u.mbm" );
_LIT( KDefinitionsFile, "AknPictographDefinitions.h" );
_LIT( KRangeFile, "AknPictographRange.h" );
_LIT( KBuildBitmapsFile, "BuildBitmaps.cmd" );
_LIT8( KGeneratedInfo, "// This file is generated by AknPictoBitmapBuilder.\r\n\r\n" );
// Bmconv command file strings
_LIT8( KBmconvParameters, "/q " );
_LIT8( KBmpDefaultPath, "..\\..\\AknPictographBitmaps\\data\\" );
// Definition header strings
_LIT8( KDefinitionHeaderStart,
"#include <e32std.h>\r\n"
"#include \"AknPictographDrawerInterface.h\"\r\n"
"#include \"AknPictographConstants.h\"\r\n\r\n" );
// TAknPictographSupportedHeights array
_LIT8( KAknPictographSupportedHeightsStart,
"const TAknPictographHeight TAknPictographSupportedHeights[] =\r\n" );
_LIT8( KAknPictographSupportedHeightsArrayRow,
" EHeight%u,\r\n" );
// TAknPictographSupportedHeightsNumbers array
_LIT8( KAknPictographSupportedHeightsNumbersStart,
"const TUint TAknPictographSupportedHeightsNumbers[] =\r\n" );
_LIT8( KAknPictographSupportedHeightsNumbersArrayRow,
" %u,\r\n" );
// KAknPictographSupportedHeightsCount row
_LIT8( KAknPictographSupportedHeightsCount,
"const TInt KAknPictographSupportedHeightsCount = sizeof(TAknPictographSupportedHeights)/sizeof(TAknPictographHeight);\r\n\r\n" );
// Animation definitions
_LIT8( KAnimationDefinitionStart,
"const TAknPictographMetrics P_%x_%u[] =\r\n" );
_LIT8( KAnimationFrame,
" {%u, %u, %u},\r\n" );
// Animation frames definitions
_LIT8( KAnimationFramesDefinitionStart,
"const TAknAnimatedPictographFramesDefinition Frames_%x[] =\r\n" );
_LIT8( KAnimationFramesDefinitionRow,
" {%u, P_%x_%u},\r\n" );
// Animated pictograph table
_LIT8( KAnimatedTableStart,
"const TAknAnimatedPictographDefinition TheAnimatedPictographDefinitions[] =\r\n" );
_LIT8( KAnimatedTableRow,
" { 0x%x, %u, Frames_%x },\r\n" );
_LIT8( KAnimatedTableDummyRow,
" { 0x0000, 0, NULL }\r\n" );
// KAknPictographAnimatedPictographsCount row
_LIT8( KAknPictographAnimatedPictographsCount,
"const TInt KAknPictographAnimatedPictographsCount = sizeof(TheAnimatedPictographDefinitions)/sizeof(TAknAnimatedPictographDefinition) - %u;\r\n\r\n" );
// Static definitions
_LIT8( KStaticDefinitionStart,
"const TAknPictographMetrics Static_%x[] =\r\n" );
_LIT8( KStaticDefinitionRow,
" {%u, %u, %u},\r\n" );
// Static pictograph table
_LIT8( KStaticTableStart,
"const TAknStaticPictographDefinition TheStaticPictographDefinitions[] =\r\n" );
_LIT8( KStaticTableRow,
" { 0x%x, Static_%x },\r\n" );
_LIT8( KStaticTableDummyRow,
" { 0x0000, NULL }\r\n" );
// KAknPictographAnimatedPictographsCount row
_LIT8( KAknPictographStaticPictographsCount,
"const TInt KAknPictographStaticPictographsCount = sizeof(TheStaticPictographDefinitions)/sizeof(TAknStaticPictographDefinition) - %u;\r\n\r\n" );
// Range header strings
_LIT8( KRangeHeaderStart,
"#ifndef AKN_PICTOGRAPH_RANGE_H\r\n"
"#define AKN_PICTOGRAPH_RANGE_H\r\n\r\n"
"#include <e32std.h>\r\n\r\n" );
_LIT8( KRangeStart,
"const TText KPictographRangeStart = 0x%x;\r\n" );
_LIT8( KRangeEnd,
"const TText KPictographRangeEnd = 0x%x;\r\n\r\n" );
_LIT8( KEndIf, "#endif\r\n\r\n" );
// Common for all arrays
_LIT8( KArrayStart, " {\r\n" );
_LIT8( KArrayEnd, " };\r\n\r\n" );
_LIT8( KHeaderEnd, "// End of File" );
// BuildBitmaps.cmd strings
_LIT8( KBuildBitmapsFileStart,
"@echo off\r\n"
"rem\r\n"
"rem This file is generated by AknPictoBitmapBuilder.\r\n"
"rem\r\n\r\n"
"if %1==xip goto xip_rom\r\n"
"if %1==XIP goto xip_rom\r\n\r\n"
"set bmconv_params=/q\r\n"
"goto main\r\n\r\n"
":xip_rom\r\n"
"set bmconv_params=/q /r\r\n\r\n"
":main\r\n\r\n");
_LIT8( KBuildBitmapsRow,
"bmconv ..\\generated\\bmconv%u.txt&&^\r\n");
_LIT8( KBuildFinalBitmaps,
"\\epoc32\\release\\winscw\\urel\\AknPictoBitmapBuilder.exe -Dnogui -D_epoc_drive_a=%~pd2 -- 2&&^\r\n"
"cd ..\\generated&&^\r\n");
_LIT8( KCompressFinalBitmapsRow,
"bmconv %%bmconv_params%% AknPictograph%u_rom.mbm /mAknPictograph%u.mbm&&^\r\n"
"bmconv %%bmconv_params%% AknPictographMask%u_rom.mbm /mAknPictographMask%u.mbm&&^\r\n");
_LIT8( KMoveFinalBitmapsRow,
"move AknPictograph%u_rom.mbm %%3\\AknPictograph%u.mbm&&^\r\n"
"move AknPictographMask%u_rom.mbm %%3\\AknPictographMask%u.mbm&&^\r\n");
_LIT8( KBuildBitmapsFileEnd,
"cd ..\\group\r\n");
_LIT8( KLongCommandLineSeparator,
"rem\r\n");
// ============================ MEMBER FUNCTIONS ===============================
CPictographIniData* CPictographIniData::NewLC()
{
CPictographIniData* self = new( ELeave ) CPictographIniData;
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
void CPictographIniData::ConstructL()
{
}
CPictographIniFileData* CPictographIniFileData::NewLC()
{
CPictographIniFileData* self = new( ELeave ) CPictographIniFileData;
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
void CPictographIniFileData::ConstructL()
{
}
CPictographBitmapsData* CPictographBitmapsData::NewLC(TInt aBitmapSizesGranularity)
{
CPictographBitmapsData* self = new( ELeave ) CPictographBitmapsData(aBitmapSizesGranularity);
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
CPictographBitmapsData::CPictographBitmapsData(TInt aBitmapSizesGranularity):
iBitmapSizes(aBitmapSizesGranularity)
{
}
CPictographBitmapsData::~CPictographBitmapsData()
{
iBitmapSizes.Reset();
delete iOffsets;
}
void CPictographBitmapsData::ConstructL()
{
iOffsets = new( ELeave ) CArrayFixFlat<TInt>( 32 );
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::CBitmapBuilder
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CBitmapBuilder::CBitmapBuilder()
{
}
CBitmapBuilder* CBitmapBuilder::NewLC()
{
CBitmapBuilder* self = new( ELeave ) CBitmapBuilder;
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::ConstructL()
{
User::LeaveIfError( iFs.Connect() );
User::LeaveIfError( iFs.SetSessionPath(KDefaultPath) );
User::LeaveIfError( iFs.ShareProtected() );
}
// Destructor
CBitmapBuilder::~CBitmapBuilder()
{
iBitmapsData.ResetAndDestroy();
iIniFilesData.ResetAndDestroy();
iFs.Close();
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::EnsurePathsL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::EnsurePathsL()
{
iFs.MkDirAll( KGeneratedPathEpoc );
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::ParseIniFilesL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::ParseIniFilesL()
{
TFileName name;
TFileName temp;
for (TInt i = 0; i < KAknPictographMaxSetOfSupportedHeightsCount; i++)
{
// prepare ini file name
temp.Zero();
temp.Format( KConfigFile, TAknPictographMaxSetOfSupportedHeights[i] );
name = KConfigPathEpoc;
name.Append( temp );
CPictographIniFileData* iniFileData = NULL;
TRAPD(err, ParseIniFileL( name, iniFileData ));
if (err != KErrNotFound)
{
// Leave if the reason of leave in ParseIniFileL is not because
// of the ini file was not found
User::LeaveIfError(err);
}
if (iniFileData)
{
CleanupStack::PushL( iniFileData );
// The parsing was successful
iniFileData->iHeightIndex = i;
User::LeaveIfError( iIniFilesData.Append(iniFileData));
CleanupStack::Pop( iniFileData );
}
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::ParseIniFileL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::ParseIniFileL(
const TDesC& aFilename,
CPictographIniFileData*& aIniFileData )
{
RFile file;
User::LeaveIfError( file.Open( iFs, aFilename, EFileRead ) );
CleanupClosePushL( file );
aIniFileData = CPictographIniFileData::NewLC();
TInt pos = 0;
// go in the beginning of the file
User::LeaveIfError( file.Seek( ESeekStart, pos ) );
TInt size = 0;
file.Size( size );
HBufC8* buffer = HBufC8::NewMaxLC( size );
TPtr8 ptr = buffer->Des();
file.Read( ptr );
TLex8 lex( ptr );
TPtrC8 token( lex.NextToken() );
while ( token.Length() )
{
// code tag first
if ( token.Length() != 8 ||
token[0] != '[' ||
token[1] != '0' ||
( token[2] != 'x' && token[2] != 'X' ) ||
token[7] != ']' )
{
User::Leave( KErrCorrupt );
}
CPictographIniData* data = CPictographIniData::NewLC();
TLex8 codeLex( token.Mid( 3, 4 ) );
User::LeaveIfError( codeLex.Val( data->iCode, EHex ) );
// filename parameters then
for ( token.Set( lex.NextToken() ) ;
token.Length() && token[0] != '[' ;
token.Set( lex.NextToken() ) )
{
HBufC8* filename = token.AllocLC();
User::LeaveIfError( data->iFilenameArray.Append( filename ) );
CleanupStack::Pop( filename );
aIniFileData->iBmps++;
}
// Must be even number because each bitmap must have mask
if ( data->iFilenameArray.Count() % 2 != 0 )
{
User::Leave( KErrCorrupt );
}
User::LeaveIfError( aIniFileData->iIniData.Append( data ) );
CleanupStack::Pop( data );
}
CleanupStack::PopAndDestroy( buffer );
CleanupStack::Pop( aIniFileData );
CleanupStack::PopAndDestroy(); // file
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateBmconvCommandFilesL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateBmconvCommandFilesL()
{
TFileName cmdFile;
TFileName bitmapFile;
TFileName temp;
for (TInt i = 0; i < iIniFilesData.Count(); i++)
{
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[i]->iHeightIndex];
// prepare cmdFile name
temp.Zero();
temp.Format( KBmconvFile, height );
cmdFile = KGeneratedPathEpoc;
cmdFile.Append( temp );
// prepare bitmapFile name
temp.Zero();
temp.Format( KMultiBitmapFile, height );
bitmapFile = KGeneratedPath;
bitmapFile.Append( temp );
GenerateBmconvCommandFileL( cmdFile, bitmapFile, iIniFilesData[i]->iIniData );
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateBmconvCommandFilesL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateBuildBitmapsCommandFileL()
{
TFileName aCmdFileName;
TBuf8<256> temp;
// prepare cmdFile name
aCmdFileName = KGeneratedPathEpoc;
aCmdFileName.Append( KBuildBitmapsFile );
RFile file;
User::LeaveIfError( file.Replace( iFs, aCmdFileName, EFileWrite ) );
CleanupClosePushL( file );
TInt pos = 0;
// go in the beginning of the file
User::LeaveIfError( file.Seek( ESeekStart, pos ) );
file.Write( KBuildBitmapsFileStart );
// generate bitmaps building section
for (TInt i = 0; i < iIniFilesData.Count(); i++)
{
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[i]->iHeightIndex];
temp.Zero();
temp.Format( KBuildBitmapsRow, height );
file.Write( temp );
}
file.Write( KLongCommandLineSeparator );
file.Write( KBuildFinalBitmaps );
// generate compress final bitmaps section
for (TInt j = 0; j < iIniFilesData.Count(); j++)
{
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[j]->iHeightIndex];
temp.Zero();
temp.Format( KCompressFinalBitmapsRow, height, height, height, height );
file.Write( temp );
}
file.Write( KLongCommandLineSeparator );
// generate move final bitmaps section
for (TInt k = 0; k < iIniFilesData.Count(); k++)
{
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[k]->iHeightIndex];
temp.Zero();
temp.Format( KMoveFinalBitmapsRow, height, height, height, height );
file.Write( temp );
}
file.Write( KLongCommandLineSeparator );
file.Write( KBuildBitmapsFileEnd );
CleanupStack::PopAndDestroy(); // file
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateBmconvCommandFileL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateBmconvCommandFileL(
const TDesC& aCmdFileName,
const TDesC& aBitmapFileName,
RPointerArray<CPictographIniData>& aArray )
{
RFile file;
User::LeaveIfError( file.Replace( iFs, aCmdFileName, EFileWrite ) );
CleanupClosePushL( file );
TInt pos = 0;
// go in the beginning of the file
User::LeaveIfError( file.Seek( ESeekStart, pos ) );
file.Write( KGeneratedInfo );
file.Write( KBmconvParameters );
TBuf8<400> buf8;
buf8.Copy( aBitmapFileName );
buf8.Append( _L8("\r\n\r\n") );
file.Write( buf8 );
// write bmp parameters
for ( TInt i = 0 ; i < aArray.Count() ; i++ )
{
CPictographIniData* data = aArray[i];
for ( TInt ii = 0 ; ii < data->iFilenameArray.Count() ; ii += 2 )
{
// bitmap
buf8.Zero();
buf8.Append( KBitmapTag );
TFileName filename;
// 8-bit to 16-bit copy
filename.Copy( *(data->iFilenameArray[ii]) );
TParse parse;
parse.Set( filename, NULL, NULL );
if ( !parse.PathPresent() )
{
buf8.Append( KBmpDefaultPath );
}
// 16-bit to 8-bit append
buf8.Append( parse.FullName() );
buf8.Append( _L8("\r\n") );
file.Write( buf8 );
// mask
buf8.Zero();
buf8.Append( KMaskTag );
// 8-bit to 16-bit copy
filename.Copy( *(data->iFilenameArray[ii + 1]) );
parse.Set( filename, NULL, NULL );
if ( !parse.PathPresent() )
{
buf8.Append( KBmpDefaultPath );
}
// 16-bit to 8-bit append
buf8.Append( parse.FullName() );
buf8.Append( _L8("\r\n") );
file.Write( buf8 );
}
}
CleanupStack::PopAndDestroy(); // file
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::BuildFinalBitmapsL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::BuildFinalBitmapsL()
{
TFileName* multiBitmapFile = new( ELeave ) TFileName;
CleanupStack::PushL( multiBitmapFile );
TFileName* finalBitmapFile = new( ELeave ) TFileName;
CleanupStack::PushL( finalBitmapFile );
TFileName* finalMaskFile = new( ELeave ) TFileName;
CleanupStack::PushL( finalMaskFile );
TFileName* temp = new( ELeave ) TFileName;
CleanupStack::PushL( temp );
for (TInt i = 0; i < iIniFilesData.Count(); i++)
{
// set proper value for granularity
CPictographBitmapsData* bitmapsData = CPictographBitmapsData::NewLC(iIniFilesData[i]->iBmps/2);
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[i]->iHeightIndex];
// prepare multiBitmapFile name
temp->Zero();
temp->Format( KMultiBitmapFile, height );
multiBitmapFile->Copy( KGeneratedPathEpoc );
multiBitmapFile->Append( *temp );
// prepare finalBitmapFile name
temp->Zero();
temp->Format( KBitmapFile, height );
finalBitmapFile->Copy( KGeneratedPathEpoc );
finalBitmapFile->Append( *temp );
// prepare finalMaskFile name
temp->Zero();
temp->Format( KMaskFile, height );
finalMaskFile->Copy( KGeneratedPathEpoc );
finalMaskFile->Append( *temp );
BuildFinalBitmapL(
*multiBitmapFile,
*finalBitmapFile,
*finalMaskFile,
iIniFilesData[i]->iBmps,
*bitmapsData);
User::LeaveIfError( iBitmapsData.Append(bitmapsData) );
CleanupStack::Pop(bitmapsData);
}
// multiBitmapFile, finalBitmapFile, finalMaskFile, temp
CleanupStack::PopAndDestroy( 4 );
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::BuildFinalBitmapL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::BuildFinalBitmapL(
const TDesC& aMultiBitmapFile,
const TDesC& aFinalBitmapFile,
const TDesC& aFinalMaskFile,
TInt aBmps,
CPictographBitmapsData& aBitmapsData )
{
TInt totalWidth = 0;
TInt maxHeight = 0;
// set proper granularity values
RPointerArray<CFbsBitmap> bitmaps(aBmps/2);
RPointerArray<CFbsBitmap> masks(aBmps/2);
CleanupResetAndDestroyPushL(bitmaps);
CleanupResetAndDestroyPushL(masks);
// First bitmap has x-offset 0
aBitmapsData.iOffsets->AppendL( 0 );
RFile multiBitmapfile;
User::LeaveIfError( multiBitmapfile.Open( iFs, aMultiBitmapFile, EFileRead ) );
CleanupClosePushL( multiBitmapfile );
// Load bitmaps and masks in arrays
for ( TInt i = 0 ; i < aBmps ; i += 2 )
{
CFbsBitmap* bitmap = new( ELeave ) CFbsBitmap;
CleanupStack::PushL( bitmap );
User::LeaveIfError( bitmap->Load( multiBitmapfile, i ) );
User::LeaveIfError( bitmaps.Append( bitmap ) );
CleanupStack::Pop( bitmap );
// Update total width and max height
TSize size = bitmap->SizeInPixels();
User::LeaveIfError( aBitmapsData.iBitmapSizes.Append( size ) );
totalWidth += size.iWidth;
aBitmapsData.iOffsets->AppendL( totalWidth );
if ( size.iHeight > maxHeight )
{
maxHeight = size.iHeight;
}
CFbsBitmap* mask = new( ELeave ) CFbsBitmap;
CleanupStack::PushL( mask );
User::LeaveIfError( mask->Load( multiBitmapfile, i + 1 ) );
User::LeaveIfError( masks.Append( mask ) );
CleanupStack::Pop( mask );
}
// new size for one large bitmap
TSize newSize( totalWidth, maxHeight );
// bitgdi objects for large bitmap
CFbsBitmap* largeBitmap = new( ELeave ) CFbsBitmap;
CleanupStack::PushL( largeBitmap );
User::LeaveIfError( largeBitmap->Create( newSize, KBitmapDisplayMode ) );
CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( largeBitmap );
CleanupStack::PushL( bitmapDevice );
CFbsBitGc* bitmapGc = NULL;
User::LeaveIfError( bitmapDevice->CreateContext( bitmapGc ) );
CleanupStack::PushL( bitmapGc );
// bitgdi objects for large mask
CFbsBitmap* largeMask = new( ELeave ) CFbsBitmap;
CleanupStack::PushL( largeMask );
User::LeaveIfError( largeMask->Create( newSize, KMaskDisplayMode ) );
CFbsBitmapDevice* maskDevice = CFbsBitmapDevice::NewL( largeMask );
CleanupStack::PushL( maskDevice );
CFbsBitGc* maskGc = NULL;
User::LeaveIfError( maskDevice->CreateContext( maskGc ) );
CleanupStack::PushL( maskGc );
// fill with black color
bitmapGc->SetBrushColor( KRgbBlack );
bitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
bitmapGc->Clear();
maskGc->SetBrushColor( KRgbBlack );
maskGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
maskGc->Clear();
TPoint point( 0, 0 );
for ( TInt j = 0 ; j < aBmps / 2 ; j++ )
{
// bitmap
bitmapGc->BitBlt( point, bitmaps[j] );
// mask
maskGc->BitBlt( point, masks[j] );
point.iX += bitmaps[j]->SizeInPixels().iWidth;
// Mask must be same size as the corresponding bitmap!
__ASSERT_ALWAYS( aBitmapsData.iBitmapSizes[j] == masks[j]->SizeInPixels(),
User::Invariant() );
}
RFile finalBitmapFile;
User::LeaveIfError( finalBitmapFile.Replace( iFs, aFinalBitmapFile, EFileWrite ) );
CleanupClosePushL( finalBitmapFile );
User::LeaveIfError( largeBitmap->Save( finalBitmapFile ) );
RFile finalMaskFile;
User::LeaveIfError( finalMaskFile.Replace( iFs, aFinalMaskFile, EFileWrite ) );
CleanupClosePushL( finalMaskFile );
User::LeaveIfError( largeMask->Save( finalMaskFile ) );
// bitmaps, masks, multiBitmapfile, largeBitmap, largeMask, bitmapDevice, bitmapGc, maskDevice, maskGc,
// finalBitmapFile, finalMaskFile
CleanupStack::PopAndDestroy( 11 );
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GeneratePictographDefinitionsL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GeneratePictographDefinitionsL()
{
TFileName name;
name = KGeneratedPathEpoc;
name.Append( KDefinitionsFile );
RFile file;
User::LeaveIfError( file.Replace( iFs, name, EFileWrite ) );
CleanupClosePushL( file );
TInt pos = 0;
// go in the beginning of the file
User::LeaveIfError( file.Seek( ESeekStart, pos ) );
HBufC8* buffer = HBufC8::NewLC( KBufferSizeForHeaderGeneration );
TPtr8 data = buffer->Des();
data.Append( KGeneratedInfo );
data.Append( KDefinitionHeaderStart );
// TAknPictographSupportedHeights array
GenerateTAknPictographSupportedHeightsArrayL( data );
// TAknPictographSupportedHeightsNumbers array
GenerateTAknPictographSupportedHeightsNumbersArrayL( data );
data.Append( KAknPictographSupportedHeightsCount );
// Animation definitions
GenerateAnimationDefinitionsL( data );
// Animation frames definitions
GenerateAnimationFramesDefinitionsL( data );
// Animated pictograph table
GenerateAnimatedPictographTableL( data );
// Static definitions
GenerateStaticDefinitionsL( data );
// Static pictorah table
GenerateStaticPictographTableL( data );
data.Append( KHeaderEnd );
User::LeaveIfError( file.Write( data ) );
CleanupStack::PopAndDestroy( 2 ); // file, buffer
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateTAknPictographSupportedHeightsArrayL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateTAknPictographSupportedHeightsArrayL(TPtr8& aData)
{
TBuf8<128> temp;
// TAknPictographSupportedHeights array
aData.Append( KAknPictographSupportedHeightsStart );
aData.Append( KArrayStart );
// any rows added in the array?
TBool rowsAdded = EFalse;
for (TInt i = 0; i < iIniFilesData.Count(); i++)
{
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[i]->iHeightIndex];
// prepare and append array row
temp.Zero();
temp.Format( KAknPictographSupportedHeightsArrayRow, height );
aData.Append( temp );
rowsAdded = ETrue;
}
if ( !rowsAdded )
{
// At least one height must be supported
User::Leave( KErrGeneral );
}
else
{
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
aData.Append( KArrayEnd );
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateTAknPictographSupportedHeightsNumbersArrayL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::
GenerateTAknPictographSupportedHeightsNumbersArrayL(TPtr8& aData)
{
TBuf8<128> temp;
// TAknPictographSupportedHeights array
aData.Append( KAknPictographSupportedHeightsNumbersStart );
aData.Append( KArrayStart );
// any rows added in the array?
TBool rowsAdded = EFalse;
for (TInt i = 0; i < iIniFilesData.Count(); i++)
{
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[i]->iHeightIndex];
// prepare and append array row
temp.Zero();
temp.Format( KAknPictographSupportedHeightsNumbersArrayRow, height );
aData.Append( temp );
rowsAdded = ETrue;
}
if ( !rowsAdded )
{
// At least one height must be supported
User::Leave( KErrGeneral );
}
else
{
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
aData.Append( KArrayEnd );
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateAnimationDefinitionsL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateAnimationDefinitionsL(TPtr8& aData)
{
TBuf8<128> temp;
// Generate Animation definitions for each supported height
for (TInt z = 0; z < iIniFilesData.Count(); z++)
{
TInt index = 0;
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[z]->iHeightIndex];
for ( TInt i = 0 ; i < iIniFilesData[z]->iIniData.Count() ; i++ )
{
RPointerArray<HBufC8>& filenameArray =
iIniFilesData[z]->iIniData[i]->iFilenameArray;
// if more than 2 bmps (bitmap and mask), it is animated
if ( filenameArray.Count() > 2 )
{
temp.Zero();
temp.Format( KAnimationDefinitionStart, iIniFilesData[z]->iIniData[i]->iCode, height);
aData.Append( temp );
aData.Append( KArrayStart );
for ( TInt ii = 0 ; ii < filenameArray.Count() ; ii += 2 )
{
TSize size = iBitmapsData[z]->iBitmapSizes[index + ii/2];
TInt offset = (*iBitmapsData[z]->iOffsets)[index + ii/2];
temp.Zero();
temp.Format( KAnimationFrame, offset, size.iWidth, size.iHeight );
aData.Append( temp );
}
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
aData.Append( KArrayEnd );
}
index += filenameArray.Count() / 2;
}
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateAnimationFramesDefinitionsL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateAnimationFramesDefinitionsL(TPtr8& aData)
{
TBuf8<128> temp;
// Generate Animation Frames definitions for each for each
// animated pictograph
if (iIniFilesData.Count())
{
for ( TInt i = 0 ; i < iIniFilesData[0]->iIniData.Count() ; i++ )
{
// Check if the pictograph is animated and
// if yes it must be animated for all supported heights
TInt rowCount = 0;
for (TInt z = 0; z < iIniFilesData.Count(); z++)
{
RPointerArray<HBufC8>& array =
iIniFilesData[z]->iIniData[i]->iFilenameArray;
// If more than 2 bmps (bitmap and mask), it is animated
if ( array.Count() > 2 )
{
if (!rowCount)
{
// Only insert table header before the first row
// Animation Frames definition table
temp.Zero();
temp.Format( KAnimationFramesDefinitionStart,
iIniFilesData[0]->iIniData[i]->iCode);
aData.Append( temp );
aData.Append( KArrayStart );
}
// get current height
TInt height = TAknPictographMaxSetOfSupportedHeights[iIniFilesData[z]->iHeightIndex];
temp.Zero();
temp.Format( KAnimationFramesDefinitionRow,
array.Count() / 2,
iIniFilesData[0]->iIniData[i]->iCode,
height);
aData.Append( temp );
rowCount++;
}
}
if ( rowCount > 0 )
{
if ( rowCount != iIniFilesData.Count() )
{
// If it is animated pictograph then it must be for all heights
User::Leave( KErrGeneral );
}
else
{
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
aData.Append( KArrayEnd );
}
}
}
}
else
{
// At least one height must be supported
User::Leave( KErrGeneral );
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateAnimatedPictographTableL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateAnimatedPictographTableL(TPtr8& aData)
{
TBuf8<256> temp;
if (iIniFilesData.Count())
{
aData.Append( KAnimatedTableStart );
aData.Append( KArrayStart );
// any rows added in the array?
TBool rowsAdded = EFalse;
for ( TInt i = 0 ; i < iIniFilesData[0]->iIniData.Count() ; i++ )
{
RPointerArray<HBufC8>& array =
iIniFilesData[0]->iIniData[i]->iFilenameArray;
// if more than 2 bmps (bitmap and mask), it is animated
if ( array.Count() > 2 )
{
// Checking if the pictograph is animated for all heights
// is done in function GenerateAnimationFramesDefinitionsL.
// It is enough to be done in one place.
temp.Zero();
temp.Format( KAnimatedTableRow,
iIniFilesData[0]->iIniData[i]->iCode,
/*rate*/1,
iIniFilesData[0]->iIniData[i]->iCode);
aData.Append( temp );
rowsAdded = ETrue;
}
}
TInt decCount = 0;
if ( !rowsAdded )
{
aData.Append( KAnimatedTableDummyRow );
decCount = 1; // This will adjust the real animated pictograph count to 0
}
else
{
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
}
aData.Append( KArrayEnd );
// Append KAknPictographAnimatedPictographsCount row
temp.Zero();
temp.Format( KAknPictographAnimatedPictographsCount, decCount );
aData.Append( temp );
}
else
{
// At least one height must be supported
User::Leave( KErrGeneral );
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateStaticDefinitionsL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateStaticDefinitionsL(TPtr8& aData)
{
TBuf8<128> temp;
// Generate Static definitions for each static pictograph
if (iIniFilesData.Count())
{
RArray<TUint> indexArray = RArray<TUint>(iIniFilesData.Count());
CleanupClosePushL( indexArray );
// Init indexes for each supported height
for (TInt k = 0; k < iIniFilesData.Count(); k++)
{
indexArray.Append(0);
}
for ( TInt i = 0 ; i < iIniFilesData[0]->iIniData.Count() ; i++ )
{
// Check if the pictograph is static and
// if yes it must be static for all supported heights
TInt rowCount = 0;
for (TInt z = 0; z < iIniFilesData.Count(); z++)
{
RPointerArray<HBufC8>& array =
iIniFilesData[z]->iIniData[i]->iFilenameArray;
// if only 2 bmps (bitmap and mask), it is static
if ( array.Count() == 2 )
{
if (!rowCount)
{
// Only insert table header before the first row
// Static definition table
temp.Zero();
temp.Format( KStaticDefinitionStart,
iIniFilesData[0]->iIniData[i]->iCode);
aData.Append( temp );
aData.Append( KArrayStart );
}
TSize size = iBitmapsData[z]->iBitmapSizes[indexArray[z]];
TInt offset = (*iBitmapsData[z]->iOffsets)[indexArray[z]];
temp.Zero();
temp.Format( KStaticDefinitionRow, offset, size.iWidth, size.iHeight );
aData.Append( temp );
rowCount++;
}
indexArray[z] += array.Count() / 2;
}
if ( rowCount > 0 )
{
if ( rowCount != iIniFilesData.Count() )
{
// If it is static pictograph then it must be for all heights
User::Leave( KErrGeneral );
}
else
{
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
aData.Append( KArrayEnd );
}
}
}
CleanupStack::PopAndDestroy(); // indexArray
}
else
{
// At least one height must be supported
User::Leave( KErrGeneral );
}
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GenerateStaticPictographTableL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GenerateStaticPictographTableL( TPtr8& aData )
{
TBuf8<256> temp;
aData.Append( KStaticTableStart );
aData.Append( KArrayStart );
// any rows added in the array?
TBool rowsAdded = EFalse;
for ( TInt i = 0 ; i < iIniFilesData[0]->iIniData.Count() ; i++ )
{
RPointerArray<HBufC8>& array =
iIniFilesData[0]->iIniData[i]->iFilenameArray;
// if only 2 bmps (bitmap and mask), it is static
if ( array.Count() == 2 )
{
// Checking if the pictograph is static for all heights
// is done in function GenerateStaticDefinitionsL.
// It is enough to be done in one place.
temp.Zero();
temp.Format( KStaticTableRow,
iIniFilesData[0]->iIniData[i]->iCode,
iIniFilesData[0]->iIniData[i]->iCode );
aData.Append( temp );
rowsAdded = ETrue;
}
}
TInt decCount = 0;
if ( !rowsAdded )
{
aData.Append( KStaticTableDummyRow );
decCount = 1; // This will adjust the real static pictograph count to 0
}
else
{
aData.Delete( aData.Length() - 3, 1 ); // remove last comma
}
aData.Append( KArrayEnd );
// Append KAknPictographStaticPictographsCount row
temp.Zero();
temp.Format( KAknPictographStaticPictographsCount, decCount );
aData.Append( temp );
}
// -----------------------------------------------------------------------------
// CBitmapBuilder::GeneratePictographRangeL
// -----------------------------------------------------------------------------
//
void CBitmapBuilder::GeneratePictographRangeL()
{
if (iIniFilesData.Count() && iIniFilesData[0]->iIniData.Count())
{
TFileName name;
name = KGeneratedPathEpoc;
name.Append( KRangeFile );
RFile file;
User::LeaveIfError( file.Replace( iFs, name, EFileWrite ) );
CleanupClosePushL( file );
TInt pos = 0;
// go in the beginning of the file
User::LeaveIfError( file.Seek( ESeekStart, pos ) );
HBufC8* buffer = HBufC8::NewLC( 4000 );
TPtr8 data = buffer->Des();
TBuf8<128> temp;
data.Append( KGeneratedInfo );
data.Append( KRangeHeaderStart );
temp.Format( KRangeStart, iIniFilesData[0]->iIniData[0]->iCode );
data.Append( temp );
temp.Format( KRangeEnd, iIniFilesData[0]->iIniData[iIniFilesData[0]->iIniData.Count() - 1]->iCode );
data.Append( temp );
data.Append( KEndIf );
data.Append( KHeaderEnd );
User::LeaveIfError( file.Write( data ) );
CleanupStack::PopAndDestroy( 2 ); // file, buffer
}
else
{
// At least one height and one pictograph must be supported
User::Leave( KErrGeneral );
}
}
// End of File