/*
* Copyright (c) 2002-2005 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 button
*
*/
// system includes
#include <barsread.h>
#include <AknIconUtils.h>
#include <coemain.h>
#include <AknsUtils.h>
// user includes
#include "peninputvkbctrllayout.h"
#include "peninputvkbctrlext.h"
// constants
const TInt KInvalidBmp = -1 ;
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::CAknFepCtrlVkbLayout
// C++ default constructor can NOT contain any code, that
// might leave.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CAknFepCtrlVkbLayout::CAknFepCtrlVkbLayout()
: iFirstTimeConstruct(ETrue), iResourceId( -1 ), iVkbLayoutId( -1 )
{
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::NewL
// Two-phased constructor.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C CAknFepCtrlVkbLayout* CAknFepCtrlVkbLayout::NewL()
{
CAknFepCtrlVkbLayout* self = NewLC();
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::NewLC
// Two-phased constructor.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C CAknFepCtrlVkbLayout* CAknFepCtrlVkbLayout::NewLC()
{
CAknFepCtrlVkbLayout* self = new (ELeave) CAknFepCtrlVkbLayout();
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::Reset
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknFepCtrlVkbLayout::Reset()
{
iVkbLayoutId = -1;
iFirstTimeConstruct = ETrue;
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::ConstructL
// Two-phased constructor.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CAknFepCtrlVkbLayout::ConstructL()
{
}
// -----------------------------------------------------------------------------
// Destructor.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C CAknFepCtrlVkbLayout::~CAknFepCtrlVkbLayout()
{
iVkbLayoutInfoList.ResetAndDestroy();
iVkbLayoutInfoList.Close();
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::SetVkbKeyboard
// Two-phased constructor.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknFepCtrlVkbLayout::SetVkbKeyboard(
CPeninputVkbCtrlExt* aVkbCtrl )
{
iVkbCtrl = aVkbCtrl;
}
EXPORT_C void CAknFepCtrlVkbLayout::SetIrregularResourceId(TInt32 aResId)
{
iIrregularResId = aResId;
}
EXPORT_C void CAknFepCtrlVkbLayout::SetNonIrregularResourceId(TInt32 aResId)
{
iNonIrregularResId = aResId;
}
EXPORT_C void CAknFepCtrlVkbLayout::ConstructFromIrregularResourceL()
{
if ( iIrregularResId < 0 )
{
return;
}
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, iIrregularResId );
TPtrC bmpFileName = reader.ReadTPtrC();
for (TInt index = 0; index <= EKeyRightUp; index ++)
{
CreateIrregularKeyBitmapsL(reader, bmpFileName, (TVirtualKeyIrregularKeyType) index);
}
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
for( TInt i = 0; i < iVkbLayoutInfoList.Count(); i++ )
{
iVkbLayoutInfoList[i]->iIrregular = ETrue;
}
}
EXPORT_C void CAknFepCtrlVkbLayout::ConstructFromNonIrregularResourceL()
{
if ( iNonIrregularResId < 0 )
{
return;
}
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, iNonIrregularResId );
TPtrC bmpFileName = reader.ReadTPtrC();
TInt32 imgMajorSkinId = reader.ReadInt32();
TAknsItemID id;
for (TInt index = 0; index <= EKeyBmpLastType ; index += 2)
{
// Get the image ids and mask ids from resource
TInt bmpId = reader.ReadInt16();
TInt bmpMskId = reader.ReadInt16();
// read skin item id
const TInt skinitemid = reader.ReadInt16();
id.Set(TInt(imgMajorSkinId), skinitemid);
if (bmpId != KInvalidBmp)
{
CFbsBitmap* bmp = NULL;
CFbsBitmap* maskbmp = NULL;
if (bmpMskId != KInvalidBmp)
{
AknsUtils::CreateIconL(AknsUtils::SkinInstance(),
id,
bmp,
maskbmp,
bmpFileName,
bmpId,
bmpMskId);
// set maskbmp and size
iVkbCtrl->SetNonIrregularKeyBitmapL(TVirtualKeyBmpType(EKeyBmpNormal + index + 1),
maskbmp );
}
else
{
AknsUtils::CreateIconL(AknsUtils::SkinInstance(),
id,
bmp,
bmpFileName,
bmpId);
}
// set bmp and size
iVkbCtrl->SetNonIrregularKeyBitmapL( TVirtualKeyBmpType(EKeyBmpNormal + index), bmp );
}
}
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
for( TInt i = 0; i < iVkbLayoutInfoList.Count(); i++ )
{
iVkbLayoutInfoList[i]->iIrregular = EFalse;
}
}
void CAknFepCtrlVkbLayout::CreateIrregularKeyBitmapsL(TResourceReader& reader, TPtrC& bmpFileName,
TVirtualKeyIrregularKeyType aKeyType)
{
int maskid = 0;
for(TInt index = 0; index <= EKeyStateDimmedMask; index += 2)
{
maskid = index + 1;
CreateIrregularKeyBitmapL(reader, bmpFileName, aKeyType ,
(TVirtualKeyIrregularKeyState)index,
(TVirtualKeyIrregularKeyState)maskid);
}
}
void CAknFepCtrlVkbLayout::CreateIrregularKeyBitmapL(TResourceReader& reader, TPtrC& bmpFileName,
TVirtualKeyIrregularKeyType aKeyType ,
TVirtualKeyIrregularKeyState aKeyState,
TVirtualKeyIrregularKeyState aKeyStateMask)
{
CFbsBitmap* bitmap = NULL;
CFbsBitmap* bitmapmaks = NULL;
TAknsItemID id;
MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();
TInt bmpID = reader.ReadInt16();
TInt bmpmaskID = reader.ReadInt16();
TInt minorskinID = reader.ReadInt16();
id.Set(TInt(EAknsMajorGeneric), minorskinID);
if (bmpID > 0)
{
AknsUtils::CreateIconL( skininstance,
id,
bitmap,
bitmapmaks,
bmpFileName,
bmpID,
bmpmaskID );
if (bitmapmaks)
{
AknIconUtils::DisableCompression(bitmapmaks);
}
if (bitmap && iVkbCtrl)
{
iVkbCtrl->AddIrregularKeyBitmapL(aKeyType, aKeyState, bitmap);
}
if (bitmapmaks && iVkbCtrl)
{
iVkbCtrl->AddIrregularKeyBitmapL(aKeyType, aKeyStateMask, bitmapmaks);
}
}
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::SetResourceId
// Set resurce Id
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknFepCtrlVkbLayout::SetResourceId(TInt32 aResId)
{
iResourceId = aResId;
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::ConstructFromResourceL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknFepCtrlVkbLayout::ConstructFromResourceL()
{
if ( iResourceId < 0 )
{
return;
}
TResourceReader reader;
CCoeEnv::Static()->CreateResourceReaderLC( reader, iResourceId );
TInt count = reader.ReadInt16();
if( iFirstTimeConstruct )
{
iVkbLayoutInfoList.ResetAndDestroy();
for ( TInt i = 0; i < count; i++ )
{
CPeninputVkbLayoutInfo* vkbLayoutInfo =
CPeninputVkbLayoutInfo::NewL( reader );
if (iVkbCtrl)
{
vkbLayoutInfo->iIrregular = iVkbCtrl->IsIrregularKeyBoard();
}
iVkbLayoutInfoList.Append( vkbLayoutInfo );
}
}
else
{
// vkb keyboard must reset first, because iKeyInfoList will reset and destroy later
if( iVkbCtrl != NULL )
{
iVkbCtrl->Reset();
}
for ( TInt i = 0; i < count; i++ )
{
iVkbLayoutInfoList[i]->ConstructFromResourceL( reader, iVkbCtrl, iVkbLayoutId );
iVkbLayoutInfoList[i]->ResetSize(
iVkbLayoutInfoList[i]->UnitWidth(),
iVkbLayoutInfoList[i]->UnitHeight(),
iVkbLayoutInfoList[i]->UnitCharWidth(),
iVkbLayoutInfoList[i]->UnitCharHeight(),
iVkbLayoutInfoList[i]->CharLeftTopPoint(),
iVkbLayoutInfoList[i]->CharFont() );
if (iVkbCtrl)
{
iVkbLayoutInfoList[i]->iIrregular = iVkbCtrl->IsIrregularKeyBoard();
}
}
}
// Pop and destroy reader
CleanupStack::PopAndDestroy( 1 );
iFirstTimeConstruct = EFalse;
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::VkbLayoutInfoList
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CPeninputVkbLayoutInfo> CAknFepCtrlVkbLayout::VkbLayoutInfoList()
{
return iVkbLayoutInfoList;
}
// ---------------------------------------------------------------------------
// CAknFepCtrlVkbLayout::ChangeVkbLayout
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C void CAknFepCtrlVkbLayout::ChangeVkbLayout( TInt aVkbLayoutId )
{
if( iVkbLayoutId == aVkbLayoutId )
{
return;
}
iVkbLayoutId = aVkbLayoutId;
for( TInt i = 0; i < iVkbLayoutInfoList.Count(); i++ )
{
if( aVkbLayoutId == iVkbLayoutInfoList[i]->LayoutID() )
{
iVkbCtrl->ReorganizeVkbKeys( iVkbLayoutInfoList[i] );
return;
}
}
}
// ------------------------------------------------------------------------
// CPeninputVkbKeyInfo::NewL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C CPeninputVkbKeyInfo* CPeninputVkbKeyInfo::NewL(
TResourceReader& aReader )
{
CPeninputVkbKeyInfo* self = new ( ELeave ) CPeninputVkbKeyInfo();
CleanupStack::PushL( self );
self->ConstructL( aReader );
CleanupStack::Pop( self );
return self;
}
// ------------------------------------------------------------------------
// CPeninputVkbKeyInfo::~CPeninputVkbKeyInfo
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C CPeninputVkbKeyInfo::~CPeninputVkbKeyInfo()
{
delete iKey;
iKey = NULL;
delete iUnicode;
iUnicode = NULL;
}
// ------------------------------------------------------------------------
// CPeninputVkbKeyInfo::ConstructL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
void CPeninputVkbKeyInfo::ConstructL( TResourceReader& aReader )
{
ConstructFromResourceL( aReader );
}
// ------------------------------------------------------------------------
// CPeninputVkbKeyInfo::ConstructFromResourceL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
void CPeninputVkbKeyInfo::ConstructFromResourceL( TResourceReader& aReader )
{
iUnicode = aReader.ReadHBufCL();
iScanCode = aReader.ReadInt16();
iBeginRow = aReader.ReadInt16();
iBeginColumn = aReader.ReadInt16();
iEndRow = aReader.ReadInt16();
iEndColumn = aReader.ReadInt16();
iHighlightBmpIndex = aReader.ReadInt16();
iHighlightMaskBmpIndex = aReader.ReadInt16();
TPtrC displayUnicode = aReader.ReadTPtrC();
TInt baseLine = 0;
iKey = CVirtualKey::NewL( *iUnicode, iScanCode, TRect(),
TRect(), baseLine, iHighlightBmpIndex, iHighlightMaskBmpIndex );
if( displayUnicode.Length() != 0 )
{
iKey->SetDisplayUnicodeL( displayUnicode );
}
}
TVirtualKeyIrregularKeyType CPeninputVkbKeyInfo::KeyTypeFromColumn(TInt aColumns)
{
if (iBeginColumn == 0)
{
return EKeyLeftDown;
}
if ((iBeginColumn == aColumns - 1) && (aColumns % 2 == 0))
{
return EKeyRightUp;
}
if ((iBeginColumn == aColumns - 1) && (aColumns % 2 == 1))
{
return EKeyRightDown;
}
if (iBeginColumn % 2 == 0)
{
return EKeyMiddleDown;
}
return EKeyMiddleUp;
}
void CPeninputVkbKeyInfo::SetIrregularKeyType(TInt aColumns)
{
if (iKey)
{
iKey->SetIrregualrKeyType(KeyTypeFromColumn(aColumns));
}
}
// ------------------------------------------------------------------------
// CPeninputVkbKeyInfo::CreateKeyL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
void CPeninputVkbKeyInfo::CreateKeyL()
{
TInt baseLine = 0;
iKey = CVirtualKey::NewL( *iUnicode, iScanCode, TRect(),
TRect(), baseLine, iHighlightBmpIndex, iHighlightMaskBmpIndex );
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::NewL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C CPeninputVkbLayoutInfo* CPeninputVkbLayoutInfo::NewL(
TResourceReader& aReader )
{
CPeninputVkbLayoutInfo* self = NewLC( aReader );
CleanupStack::Pop( self );
return self;
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::NewLC
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C CPeninputVkbLayoutInfo* CPeninputVkbLayoutInfo::NewLC(
TResourceReader& aReader )
{
CPeninputVkbLayoutInfo* self = new ( ELeave ) CPeninputVkbLayoutInfo();
CleanupStack::PushL( self );
self->ConstructL( aReader );
return self;
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::GetRealSize
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C const TSize CPeninputVkbLayoutInfo::GetRealSize(
const TInt aUnitWidth, const TInt aUnitHeight ) const
{
return TSize( aUnitWidth * iColumns, aUnitHeight * iRows );
}
EXPORT_C void CPeninputVkbLayoutInfo::ResetLayoutInfo(const TSize& aSize)
{
AknIconUtils::SetSize( iBgBmp, aSize, EAspectRatioNotPreserved );
AknIconUtils::SetSize( iBgMaskBmp, aSize, EAspectRatioNotPreserved );
}
EXPORT_C void CPeninputVkbLayoutInfo::SetKeyInfo(const TInt aRow,
const TInt aColumn,
const TRect& aKeyRect,
const TRect& aCharRect,
const CFont* aFont)
{
RPointerArray<CPeninputVkbKeyInfo> keyInfoList = KeyInfoList();
TInt count = keyInfoList.Count();
for (TInt i = 0; i < count; i++ )
{
if (keyInfoList[i] &&
keyInfoList[i]->BeginColumn() == aColumn &&
keyInfoList[i]->BeginRow() == aRow)
{
keyInfoList[i]->Key()->SetRect( aKeyRect );
return;
}
}
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::ResetSize
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C void CPeninputVkbLayoutInfo::ResetSize(
const TInt aUnitWidth,
const TInt aUnitHeight,
const TInt aUnitCharWidth,
const TInt aUnitCharHeight,
const TPoint& aCharLeftTopPoint,
const CFont* aFont )
{
iUnitWidth = aUnitWidth;
iUnitHeight = aUnitHeight;
iUnitCharWidth = aUnitCharWidth;
iUnitCharHeight = aUnitCharHeight;
iCharLeftTopPoint = aCharLeftTopPoint;
iFont = aFont;
iLastTopLeft = TPoint( 0, 0 );
// 1.Resize bk bmp and mask bmp
AknIconUtils::SetSize( iBgBmp,
TSize( aUnitWidth * iColumns, aUnitHeight * iRows ),
EAspectRatioNotPreserved );
AknIconUtils::SetSize( iBgMaskBmp,
TSize( aUnitWidth * iColumns, aUnitHeight * iRows ),
EAspectRatioNotPreserved );
// 2.Resize dim bmp and mask bmp
AknIconUtils::SetSize( iDimBmp, TSize( aUnitWidth, aUnitHeight ),
EAspectRatioNotPreserved );
AknIconUtils::SetSize( iDimMaskBmp, TSize( aUnitWidth, aUnitHeight ),
EAspectRatioNotPreserved );
// 3.Resize all highlight bmp and mask bmp
TInt count = iHighlightBmps.Count();
TInt i = 0;
for ( i = 0; i < count; i++ )
{
AknIconUtils::SetSize( iHighlightBmps[i],
TSize( aUnitWidth, aUnitHeight ), EAspectRatioNotPreserved );
}
count = iHighlightMaskBmps.Count();
for ( i = 0; i < count; i++ )
{
AknIconUtils::SetSize( iHighlightMaskBmps[i],
TSize( aUnitWidth, aUnitHeight ), EAspectRatioNotPreserved );
}
// 4.For every key, reset the key rect and char rect
RPointerArray<CPeninputVkbKeyInfo> keyInfoList = KeyInfoList();
count = keyInfoList.Count();
TPoint keyLeftTop;
TInt rows;
TInt columns;
TRect rect;
for ( i = 0; i < count; i++ )
{
if ( keyInfoList[i]->Key() )
{
if (keyInfoList[i]->BeginColumn() == 0)
{
keyLeftTop = TPoint( keyInfoList[i]->BeginColumn() * aUnitWidth,
keyInfoList[i]->BeginRow() * aUnitHeight );
}
else
{
keyLeftTop = TPoint( keyInfoList[i]->BeginColumn() * aUnitWidth -
6 * keyInfoList[i]->BeginColumn(),
keyInfoList[i]->BeginRow() * aUnitHeight );
}
if (!iIrregular)
{
keyLeftTop = TPoint( keyInfoList[i]->BeginColumn() * aUnitWidth,
keyInfoList[i]->BeginRow() * aUnitHeight );
}
rows = keyInfoList[i]->EndRow() - keyInfoList[i]->BeginRow();
columns = keyInfoList[i]->EndColumn()
- keyInfoList[i]->BeginColumn();
//Set key rect
rect = TRect( keyLeftTop, TSize( columns * aUnitWidth,
rows * aUnitHeight ) );
keyInfoList[i]->Key()->SetRect( rect );
}
}
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::~CPeninputVkbLayoutInfo
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C CPeninputVkbLayoutInfo::~CPeninputVkbLayoutInfo()
{
delete iBgBmp;
iBgBmp = NULL;
delete iBgMaskBmp;
iBgMaskBmp = NULL;
delete iDimBmp;
iDimBmp = NULL;
delete iDimMaskBmp;
iDimMaskBmp = NULL;
iHighlightBmps.ResetAndDestroy();
iHighlightBmps.Close();
iHighlightMaskBmps.ResetAndDestroy();
iHighlightMaskBmps.Close();
iKeyInfoList.ResetAndDestroy();
iKeyInfoList.Close();
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::FindKey
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C CPeninputVkbKeyInfo* CPeninputVkbLayoutInfo::FindKey(
const TInt aUnicode ) const
{
const TInt count = iKeyInfoList.Count();
for ( TInt i = 0; i < count; i++ )
{
if ( (*iKeyInfoList[i]->Unicode())[0] == aUnicode )
{
return iKeyInfoList[i];
}
}
return NULL;
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::MoveKeys
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
EXPORT_C void CPeninputVkbLayoutInfo::MoveKeys( const TPoint& aTopLeft )
{
RPointerArray<CPeninputVkbKeyInfo> keyInfoList = KeyInfoList();
const TInt count = keyInfoList.Count();
const TPoint difference = aTopLeft - iLastTopLeft;
TRect rect;
for ( TInt i = 0; i < count; i++ )
{
if ( keyInfoList[i]->Key() )
{
//Set key rect
rect = keyInfoList[i]->Key()->Rect();
rect.SetRect( rect.iTl + difference, rect.Size() );
keyInfoList[i]->Key()->SetRect( rect );
}
}
iLastTopLeft = aTopLeft;
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::CPeninputVkbLayoutInfo
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
CPeninputVkbLayoutInfo::CPeninputVkbLayoutInfo()
: iCharLeftTopPoint( TPoint(0,0) )
{
iLastTopLeft = TPoint( 0, 0 );
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::ConstructL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
void CPeninputVkbLayoutInfo::ConstructL( TResourceReader& aReader )
{
ConstructFromResourceL( aReader );
}
// ------------------------------------------------------------------------
// CPeninputVkbLayoutInfo::ConstructFromResourceL
// (other items were commented in a header)
// ------------------------------------------------------------------------
//
void CPeninputVkbLayoutInfo::ConstructFromResourceL( TResourceReader& aReader,
CPeninputVkbCtrlExt* aVkbCtrl,
TInt aVkbLayoutId )
{
delete iBgBmp;
iBgBmp = NULL;
delete iBgMaskBmp;
iBgMaskBmp = NULL;
delete iDimBmp;
iDimBmp = NULL;
delete iDimMaskBmp;
iDimMaskBmp = NULL;
iHighlightBmps.ResetAndDestroy();
iHighlightBmps.Close();
iHighlightMaskBmps.ResetAndDestroy();
iHighlightMaskBmps.Close();
iKeyInfoList.ResetAndDestroy();
iKeyInfoList.Close();
iLayoutID = aReader.ReadInt16();
// Read the file name of the bmps
TPtrC bmpFileName = aReader.ReadTPtrC();
TInt32 imgMajorSkinId = aReader.ReadInt32();
TInt layoutBmpId = aReader.ReadInt16();
TInt layoutBmpMaskId = aReader.ReadInt16();
TInt layoutBmpSkinId = aReader.ReadInt16();
TAknsItemID id;
MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();
id.Set(TInt( imgMajorSkinId ), layoutBmpSkinId);
if ( layoutBmpId != KInvalidBmp)
{
if ( layoutBmpMaskId != KInvalidBmp)
{
AknsUtils::CreateIconL( skininstance,
id,
iBgBmp,
iBgMaskBmp,
bmpFileName,
layoutBmpId,
layoutBmpMaskId );
}
else
{
AknsUtils::CreateIconL( skininstance,
id,
iBgBmp,
bmpFileName,
layoutBmpId );
}
}
TInt dimBmpId = aReader.ReadInt16();
TInt dimMaskBmpId = aReader.ReadInt16();
TInt dimBmpSkinId = aReader.ReadInt16();
id.Set( TInt( imgMajorSkinId ), dimBmpSkinId );
if ( dimBmpId != KInvalidBmp )
{
if ( dimMaskBmpId != KInvalidBmp )
{
AknsUtils::CreateIconL( skininstance,
id,
iDimBmp,
iDimMaskBmp,
bmpFileName,
dimBmpId,
dimMaskBmpId );
}
else
{
AknsUtils::CreateIconL( skininstance,
id,
iDimBmp,
bmpFileName,
dimBmpId );
}
}
iColumns = aReader.ReadInt16();
iRows = aReader.ReadInt16();
TInt i;
TInt count = aReader.ReadInt16();
TInt bmpId;
for ( i = 0; i < count; i++ )
{
bmpId = aReader.ReadInt16();
if ( bmpId != KInvalidBmp )
{
CFbsBitmap* bmp = AknIconUtils::CreateIconL( bmpFileName,
bmpId );
CleanupStack::PushL( bmp );
iHighlightBmps.Append( bmp );
CleanupStack::Pop( bmp );
}
}
count = aReader.ReadInt16();
for ( i = 0; i < count; i++ )
{
bmpId = aReader.ReadInt16();
if ( bmpId != KInvalidBmp )
{
CFbsBitmap* bmp = AknIconUtils::CreateIconL( bmpFileName, bmpId );
CleanupStack::PushL( bmp );
iHighlightMaskBmps.Append( bmp );
CleanupStack::Pop( bmp );
}
}
count = aReader.ReadInt16();
for ( i = 0; i < count; i++ )
{
CPeninputVkbKeyInfo* keyInfo = CPeninputVkbKeyInfo::NewL( aReader );
keyInfo->SetIrregularKeyType(iColumns);
iKeyInfoList.Append( keyInfo );
}
if ( ( iLayoutID == aVkbLayoutId ) && ( aVkbCtrl ) )
{
aVkbCtrl->ReorganizeVkbKeys( this );
}
}
// End Of File