1 /*

     2 * Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  

    15 *

    16 */

    17 

    18 

    19 // disable "identifier was truncated to '255' characters in the browser information" warning

    20 #pragma warning (disable:4786)

    21 

    22 // disable "decorated name length exceeded, name was truncated" warning	

    23 #pragma warning (disable:4503)

    24 

    25 #include "MLCompDataParse.h"

    26 #include "MLCompCdl2InstO.h"

    27 #include "ZoomLevelNames.h"

    28 #include "LayoutCompilerErr.h"

    29 #include "LayoutParse.h"

    30 #include "CppWriter.h"

    31 #include "MLCompData2Cdl.h"

    32 #include "LayCdl2InstO.h" // for common classes

    33 #include "MLAttributesParse.h"

    34 #include "MLAttributes.h"

    35 #include "CodeGenConsts.h"

    36 #include "UsefulDefinitions.h"

    37 

    38 #include <akndef.hrh>

    39 

    40 #include <fstream>

    41 #include <algorithm>

    42 #include <iostream>

    43 #include <numeric> // accumulate

    44 

    45 using namespace std;

    46 using namespace CdlCompilerToolkit;

    47 

    48 //

    49 // defines

    50 //

    51 

    52 #define AKNLAYOUT_DEFINE_BYTECODE(name,byte) const char name = char(byte);

    53 #include "AknLayoutByteCodes.h"

    54 

    55 typedef LayoutProcessArgsErr<MLCompDataCdlInstanceOpt> MLCompDataCdlInstanceOptArgsErr;

    56 

    57 

    58 //

    59 // constants

    60 //

    61 

    62 const string KDefinitionNotDefined("Layout not defined, this API must not be called for this instance");

    63 const string KDefinitionNotSet("Layout definition not found");

    64 extern string KMultiLine;

    65 const string KSpace = " ";

    66 const string KComma = ",";

    67 const string KTheWordBlank("blank");

    68 const string KParentRelativeMarker("Pp");

    69 const string KCellNameJustification("J");

    70 const string KCompDataFileNameSuffix("compData");

    71 const string KAttributesFileNameSuffix("attributes");

    72 

    73 // this is the addressable area for each instance, as the lookup table is 16bit

    74 const int KAddressableBytecodedData = 0xFFFF;

    75 

    76 /**

    77 *  SCompDataImplFunc

    78 *  This class represents a layout data decompression function local to a layout instance.

    79 *  These functions will call the corresponding DLL wide function for decompression.

    80 */

    81 struct SCompDataImplFunc

    82 	{

    83 	enum TFuncType

    84 		{ 

    85 		EWindowLine, 

    86 		ETextLine,

    87 		ETableLimits,

    88 		EWindowTable, 

    89 		ETextTable,

    90 		ELineParamLimits,

    91 		ETableParamLimits,

    92 		EGenericComponentType,

    93 		EGenericParamLimits,

    94 		EGenericWindowComponent,

    95 		EGenericTextComponent

    96 		};

    97 	TFuncType iType;

    98 	CCdlTkApiParams iParams;

    99 	string iDefn;

   100 	string iPtrRef;

   101 

   102 	SCompDataImplFunc(TFuncType aType, string aDefn, string aPtrRef, CCdlTkApiParams& aParams)

   103 		: 

   104 		iType(aType), 

   105 		iDefn(aDefn), 

   106 		iPtrRef(aPtrRef),

   107 		iParams(aParams)

   108 		{

   109 			

   110 		}

   111 

   112 	SCompDataImplFunc(TFuncType aType, string aDefn, string aPtrRef)

   113 		: 

   114 		iType(aType), 

   115 		iDefn(aDefn), 

   116 		iPtrRef(aPtrRef)

   117 		{

   118 			

   119 		}

   120 

   121 	bool IsSimilar(TFuncType aType, CCdlTkApiParams& aParams)

   122 		{

   123 		if(iType != aType) 

   124 			return false;

   125 		int size = iParams.size();

   126 		if(size != aParams.size())

   127 			return false;

   128 		for(int ii = 0; ii < size; ii++)

   129 			{

   130 			CCdlTkApiParam& thisParam = iParams[ii];

   131 			CCdlTkApiParam& otherParam = aParams[ii];

   132 			if(thisParam.Name() != otherParam.Name())

   133 				return false;

   134 			if(thisParam.Type() != otherParam.Type())

   135 				return false;

   136 			// don't compare the default value, as we're not interested in that for the implementation.

   137 			}

   138 		return true;

   139 		}

   140 	};

   141 

   142 

   143 /**

   144 *  CAllCompDataFuncs

   145 *  This represents a collection of all the SCompDataImplFunc objects that a layout instance may need

   146 */

   147 class CAllCompDataFuncs : public vector<SCompDataImplFunc>

   148 	{

   149 public:

   150 	CAllCompDataFuncs();

   151 

   152 private:

   153 	void AddFunc(SCompDataImplFunc::TFuncType aType, CCdlTkApiParams& aParams, const string& aReturn, const string& aFuncName, bool aAppendAbbreviation);

   154 	void AddParamsToFunc(CCdlTkApiParams& aParams, string& aDefn, string& aBody);

   155 	void AddParamToFunc(string aFiller, string aParamName, string& aDefn, string& aBody);

   156 	};

   157 

   158 

   159 

   160 /**

   161 *  gTheFuncs

   162 *  This is a collection of all SCompDataImplFunc objects that a layout instance needs, initialised

   163 *  so that there are up to four integer parameters per API type.

   164 */

   165 CAllCompDataFuncs gTheFuncs;

   166 

   167 //

   168 // CAllCompDataFuncs

   169 //

   170 

   171 CAllCompDataFuncs::CAllCompDataFuncs()

   172 	{

   173 	// need to generate all combinations of parameters

   174 	vector<string> paramNames;

   175 	paramNames.push_back(KParamOptionIndex);

   176 	paramNames.push_back(KParamColIndex);

   177 	paramNames.push_back(KParamRowIndex);

   178 

   179 	// all cominations of option, row, and column are possible, in any order

   180 	typedef vector<int> Seq;

   181 	Seq pattern;

   182 	set< Seq > subPatterns;

   183 

   184 	// for each of the available positions, there could be any available value, or it could be empty

   185 	const int numPlaces = paramNames.size();

   186 	for(int jj = 0; jj < numPlaces; jj++)

   187 		pattern.push_back(jj);

   188 

   189 	// for each permutation, copy all the possible positions

   190 	// into a separate set, which hence will be filled with the unique permutations

   191 	do

   192 		{

   193 		int numMasks = (1 << numPlaces); // eg for 3 places there are 8 masks

   194 		for(int mask = 0; mask < numMasks; mask++)

   195 			{

   196 			Seq subPattern;

   197 			int bit = 0;

   198 			// count down the bits

   199 			for(int bitCount = mask; bitCount != 0; bitCount >>= 1)

   200 				{

   201 				if(mask & (1 << bit))

   202 					subPattern.push_back(pattern[bit]);

   203 				bit++;

   204 				}

   205 			subPatterns.insert(subPattern);

   206 			}

   207 		}

   208 	while(next_permutation(pattern.begin(), pattern.end()));

   209 

   210 	for(set< Seq >::iterator pPattern = subPatterns.begin(); pPattern != subPatterns.end(); ++pPattern)

   211 		{

   212 		CCdlTkApiParams params;

   213 		for(Seq::iterator pParam = pPattern->begin(); pParam != pPattern->end(); ++pParam)

   214 			{

   215 			int& param = (*pParam);

   216 			string name = paramNames[param];

   217 			params.push_back(CCdlTkApiParam(KTypeInt, name));

   218 			}

   219 		AddFunc(SCompDataImplFunc::EWindowLine, params, KTypeWindowComponentLayout, KFuncWindowLine, true);

   220 		AddFunc(SCompDataImplFunc::ETextLine, params, KTypeTextComponentLayout, KFuncTextLine, true);

   221 

   222 		params.insert(params.begin(), CCdlTkApiParam(KTypeInt, KParamLineIndex));

   223 		AddFunc(SCompDataImplFunc::EWindowTable, params, KTypeWindowComponentLayout, KFuncWindowTable, true);

   224 		AddFunc(SCompDataImplFunc::ETextTable, params, KTypeTextComponentLayout, KFuncTextTable, true);

   225 		}

   226 

   227 	for(int ii = 0; ii < 2; ii++)

   228 		{

   229 		CCdlTkApiParams params;

   230 		if(ii)

   231 			{

   232 			params.push_back(CCdlTkApiParam(KTypeInt, KParamOptionIndex));

   233 			}

   234 		AddFunc(SCompDataImplFunc::ELineParamLimits, params, KTypeLayoutScalableParameterLimits, KFuncParamLimits, true);

   235 		params.insert(params.begin(), CCdlTkApiParam(KTypeInt, KParamLineIndex));

   236 		AddFunc(SCompDataImplFunc::ETableParamLimits, params, KTypeLayoutScalableParameterLimits, KFuncParamLimitsTable, true);

   237 		}

   238 

   239 	SCompDataImplFunc limits(

   240 		SCompDataImplFunc::ETableLimits, 

   241 		KTypeLayoutScalableTableLimits + " Limits() { return AknLayoutScalableDecode::TableLimits(KDataLookup); }",

   242 		"&Limits");

   243 	push_back(limits);

   244 

   245 	// finally, the generic APIs

   246 	CCdlTkApiParams params;

   247 	params.push_back(CCdlTkApiParam(KTypeInt, KParamComponentId));

   248 	AddFunc(SCompDataImplFunc::EGenericComponentType, params, KTypeLayoutScalableComponentType, KFuncGetComponentTypeById, false);

   249 

   250 	// param limits needs the variety index

   251 	params.push_back(CCdlTkApiParam(KTypeInt, KParamOptionIndex));

   252 	AddFunc(SCompDataImplFunc::EGenericParamLimits, params, KTypeLayoutScalableParameterLimits, KFuncGetParamLimitsById, false);

   253 

   254 	// and getting the component by id requires all the params

   255 	params.push_back(CCdlTkApiParam(KTypeInt, KParamColIndex));

   256 	params.push_back(CCdlTkApiParam(KTypeInt, KParamRowIndex));

   257 	AddFunc(SCompDataImplFunc::EGenericWindowComponent, params, KTypeWindowComponentLayout, KFuncGetWindowComponentById, false);

   258 	AddFunc(SCompDataImplFunc::EGenericTextComponent, params, KTypeTextComponentLayout, KFuncGetTextComponentById, false);

   259 	}

   260 

   261 void CAllCompDataFuncs::AddFunc(SCompDataImplFunc::TFuncType aType, CCdlTkApiParams& aParams, const string& aReturn, const string& aFuncName, bool aAppendAbbreviation)

   262 	{

   263 	// create a function of this form:

   264 	//TAknWindowComponentLayout WindowTable$NUM$PARENT($PARAMS_TYPES_AND_NAMES)

   265 	//	{

   266 	//	return AknLayoutScalableDecode::WindowLine$NUM$PARENT(&KImplData, $PARAM_NAMES);

   267 	//  }

   268 	string funcName = aFuncName;

   269 	if(aAppendAbbreviation)

   270 		for(CCdlTkApiParams::iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)

   271 			funcName += pParam->Name().substr(1, 1); // append the first character after the "a"

   272 

   273 	string defn = aReturn + " " + funcName + "(";

   274 	string body = string(") { return AknLayoutScalableDecode::") + funcName + "(&KImplData";

   275 	AddParamsToFunc(aParams, defn, body);

   276 	defn += body + "); }";

   277 

   278 	string ptrRef = string("&") + funcName;

   279 

   280 	SCompDataImplFunc func(aType, defn, ptrRef, aParams);

   281 	push_back(func);

   282 	}

   283 

   284 void CAllCompDataFuncs::AddParamsToFunc(CCdlTkApiParams& aParams, string& aDefn, string& aBody)

   285 	{

   286 	string filler = "";

   287 	for(CCdlTkApiParams::iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)

   288 		{

   289 		AddParamToFunc(filler, pParam->Name(), aDefn, aBody);

   290 		filler = KComma + KSpace;

   291 		}

   292 	}

   293 

   294 void CAllCompDataFuncs::AddParamToFunc(string aFiller, string aParamName, string& aDefn, string& aBody)

   295 	{

   296 	aDefn += aFiller + string(KTypeInt) + KSpace + aParamName;

   297 	aBody += KComma + KSpace + aParamName;

   298 	}

   299 

   300 

   301 //

   302 // CMLCompDataInstOptImpl

   303 //

   304 

   305 class CMLCompDataInstOptImpl

   306 	{

   307 public:

   308 	CMLCompDataInstOptImpl(CCdlTkImplementation* aImpl);

   309 	virtual ~CMLCompDataInstOptImpl();

   310 public:

   311 	CCdlTkImplementation* iImpl;

   312 	int iByteCodeIndex;

   313 	string iComment;

   314 	string iName;

   315 	vector<char> iBytes;

   316 	bool iIsRedirectedToExactCopy;

   317 	};

   318 

   319 CMLCompDataInstOptImpl::CMLCompDataInstOptImpl(CCdlTkImplementation* aImpl)

   320 	:

   321 	iImpl(aImpl),

   322 	iIsRedirectedToExactCopy(false)

   323 	{

   324 	}

   325 

   326 CMLCompDataInstOptImpl::~CMLCompDataInstOptImpl()

   327 	{

   328 	}

   329 

   330 //

   331 // CMLCompDataLineInstOptImpl

   332 //

   333 

   334 class CMLCompDataLineInstOptImpl : public CMLCompDataInstOptImpl

   335 	{

   336 public:

   337 	CMLCompDataLineInstOptImpl(TMLCompDataLine* aLine, CCdlTkImplementation* aImpl);

   338 	virtual ~CMLCompDataLineInstOptImpl();

   339 public:

   340 	TMLCompDataLine* iLine;

   341 	};

   342 

   343 CMLCompDataLineInstOptImpl::CMLCompDataLineInstOptImpl(TMLCompDataLine* aLine, CCdlTkImplementation* aImpl)

   344 	: 

   345 	CMLCompDataInstOptImpl(aImpl),

   346 	iLine(aLine)

   347 	{

   348 	}

   349 

   350 CMLCompDataLineInstOptImpl::~CMLCompDataLineInstOptImpl()

   351 	{

   352 	}

   353 

   354 

   355 //

   356 // CMLCompDataSubTableInstOptImpl

   357 //

   358 

   359 class CMLCompDataSubTableInstOptImpl : public CMLCompDataInstOptImpl

   360 	{

   361 public:

   362 	CMLCompDataSubTableInstOptImpl(

   363 		TMLCompDataTable* aTable,

   364 		TMLCompDataTable::TMLCompDataSubTable* aSubTable, 

   365 		CCdlTkImplementation* aImpl);

   366 	virtual ~CMLCompDataSubTableInstOptImpl();

   367 public:

   368 	TMLCompDataTable* iTable;

   369 	TMLCompDataTable::TMLCompDataSubTable* iSubTable;

   370 	};

   371 

   372 CMLCompDataSubTableInstOptImpl::CMLCompDataSubTableInstOptImpl(

   373 	TMLCompDataTable* aTable,

   374 	TMLCompDataTable::TMLCompDataSubTable* aSubTable, 

   375 	CCdlTkImplementation* aImpl)

   376 	:

   377 	iTable(aTable),

   378 	CMLCompDataInstOptImpl(aImpl),

   379 	iSubTable(aSubTable)

   380 	{

   381 	}

   382 

   383 CMLCompDataSubTableInstOptImpl::~CMLCompDataSubTableInstOptImpl()

   384 	{

   385 	}

   386 

   387 

   388 //

   389 // CMLCompDataInstOpt

   390 //

   391 

   392 class CMLCompDataInstOpt

   393 	{

   394 public:

   395 	CMLCompDataInstOpt(MLCompDataCdlInstanceOpt& aInstances, TMLCompData* aLayout, const string& aInstName, const string& aZoomName, int aZoomLevel, bool aAllParams, bool aNonCompleteInstance);

   396 	~CMLCompDataInstOpt();

   397 

   398 	void Process(const string& aFirstInstanceName);

   399 	void WriteInstance();

   400 

   401 	CCdlTkInstance& Inst() const { return *iInstance; }

   402 	string Name() const { return iName; }

   403 	string ZoomName() const { return iZoomName; }

   404 

   405 private:

   406 	typedef vector<int> ParamLimitVarieties;

   407 	typedef vector<ParamLimitVarieties> ParamLimits;

   408 	typedef map<int, int> IndexMap;

   409 

   410 private:

   411 	void ProcessLines(TMLCompDataTable& aTable);

   412 	void ProcessTables(TMLCompDataTable& aTable);

   413 	void ProcessLine(TMLCompDataLine& aLine);

   414 	void ProcessLineApi(TMLCompDataLine& aLine, CCdlTkImplementation& aImpl);

   415 	void UpdateBaseOffset();

   416 	void UpdateLine(CMLCompDataInstOptImpl& aImpl, int& aByteCodeSizeDelta);

   417 	void UpdateLineImpls();

   418 	void UpdateLineImplDefn(CMLCompDataInstOptImpl& aImpl);

   419 	void UpdateTableInstance(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSub, CMLCompDataInstOptImpl* aImpl);

   420 

   421 	void SetNewLineData(CMLCompDataLineInstOptImpl& aImpl);

   422 	void SetNewLineParamData(CMLCompDataLineInstOptImpl& aImpl, IndexMap& aIndexMap, int aTotalMax, int aNumVarieties);

   423 	void OptimizeNewLineData(CMLCompDataLineInstOptImpl& aImpl, IndexMap& aIndexMap, vector<char>& aTempBytes, const vector<string>& aOutputOrder, bool aMirrored, int aTotalMax, int aNumVarieties);

   424 	void OptimizeNewLineCellData(IndexMap& aIndexMap, vector<char>& aTempBytes, TMLCompDataValues& aValues, unsigned int& aNextCell, int aTotalParams, int aNumVarieties, ParamLimitVarieties& aParamLimitVarieties, string cellName, bool aMirrorJustification);

   425 	void EncodeNewLineCellData(IndexMap& aIndexMap, vector<char>& aTempBytes, vector<string>& aValuesToEncode, unsigned int& aNextCell, int aTotalMax, bool aOptimizeVarieties, bool aOptimizeCalcs);

   426 

   427 	bool HasApi(const string& aName);

   428 	CCdlTkImplementation& FindImp(const string& aName);

   429 	CMLCompDataInstOptImpl* FindSimilarImpl(const CMLCompDataInstOptImpls& aImpls, const CCdlTkImplementation& aImpl);

   430 	string DefinitionString(int aByteCodeIndex, const string& aApiName);

   431 	bool CheckByteCodeIndexInRange(int aByteCodeIndex);

   432 

   433 	void SetGenericFunc(CMLCompDataInstOptImpl& aImpl, SCompDataImplFunc::TFuncType aType);

   434 	void SetLineFunc(CMLCompDataLineInstOptImpl& aImpl);

   435 	void SetSubTableFunc(CMLCompDataSubTableInstOptImpl& aImpl);

   436 	void SetParamLimits(CMLCompDataLineInstOptImpl& aImpl);

   437 

   438 	void ValidateRequiredParams(string aApiName, CCdlTkApiParams& aParams, bool aOption, bool aColumn, bool aRow);

   439 	void CountApiParams(CCdlTkImplementation& aApi, int& aParams);

   440 	SCompDataImplFunc& AddImplFunc(SCompDataImplFunc::TFuncType aType);

   441 	SCompDataImplFunc& AddImplFunc(SCompDataImplFunc::TFuncType aType, CCdlTkApiParams& aParams);

   442 

   443 	void SetGenericAPI(SCompDataImplFunc::TFuncType aType, const string& aName);

   444 	void SetExtraCpp(const string& aFirstInstanceName);

   445 	void OutputStats();

   446 

   447 	void AddTableToInstance(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSub, int aTableNum);

   448 	void UpdateTables(TMLCompDataTable& aTable);

   449 	void AddTableParamLimitsImpl(const string& aApiName, int aByteCodeIndex, SCompDataImplFunc::TFuncType aType, bool aNeedsOptions);

   450 	void UpdateTableParamLimitsImpl(const string& aApiName, int aByteCodeIndex);

   451 	void AddTableLimitsImpl(const string& aApiName, TMLCompDataTable::TMLCompDataSubTable& aSubTable);

   452 	void AddTableLimitsImplDefn(TMLCompDataTable::TMLCompDataSubTable& aSubTable, CCdlTkImplementation& aImpl);

   453 	void AddTableImpl(const string& aApiName, TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSub);

   454 	void AddParamLimits(TMLCompDataLine& aLine, bool aNeedsOptions);

   455 	void UpdateParamLimits(const string& apiName);

   456 	void SetDummyTableData(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSubTable, CMLCompDataInstOptImpl& aImpl);

   457 	void UpdateTableData(TMLCompDataTable& aTable, TMLCompDataTable::TMLCompDataSubTable& aSubTable, CMLCompDataInstOptImpl& aImpl);

   458 	void EncodeValue(vector<char>& aBytes, string aValue);

   459 	void EncodeValue(vector<char>& aBytes, int aValue);

   460 	void EncodeParentRelativeValue(vector<char>& aBytes, int aValue);

   461 	void MirrorParamName(string& aParamName);

   462 

   463 private:

   464 	MLCompDataCdlInstanceOpt& iInstances;

   465 	TMLCompData* iLayout;

   466 	string iName;

   467 	string iZoomName;

   468 	CCdlTkInterface& iInterface;

   469 	CCdlTkInstance* iInstance; // not owned

   470 	CMLCompDataInstOptImpls iImpls;

   471 	CMLCompDataInstOptImpls iTableImpls;

   472 	typedef vector<SCompDataImplFunc*> CImplFuncs;

   473 	CImplFuncs iFuncs;

   474 	int iZoomLevel;

   475 	bool iAllParams;

   476 	int iBaseOffset; // offset from the start of the main data table to the start of this instance's data

   477 	};

   478 

   479 CMLCompDataInstOpt::CMLCompDataInstOpt(MLCompDataCdlInstanceOpt& aInstances, TMLCompData* aLayout, const string& aInstName, const string& aZoomName, int aZoomLevel, bool aAllParams, bool aNonCompleteInstance)

   480 	: 

   481 	iInstances(aInstances), 

   482 	iLayout(aLayout),

   483 	iName(aInstName), 

   484 	iZoomName(aZoomName), 

   485 	iZoomLevel(aZoomLevel),

   486 	iInterface(iInstances.Interface()),

   487 	iAllParams(aAllParams),

   488 	iBaseOffset(0)

   489 	{

   490 	string zoomInstName = aInstName;

   491 	if(aZoomName.length() > 0)

   492 		zoomInstName += "_" + aZoomName;

   493 

   494 	iInstance = new CCdlTkInstance(iInterface);

   495 	iInstance->SetName(zoomInstName);

   496 

   497 	CCdlTkImplementations& impl = iInstance->Impl();

   498 	for (CCdlTkImplementations::iterator pImpl = impl.begin(); pImpl != impl.end(); ++pImpl)

   499 		{

   500 		const CCdlTkInterface& iface = (*pImpl)->Instance().Interface();

   501 		const CCdlTkApi& api = (*pImpl)->Api();

   502 		if(aLayout->iIsBaseInstance)

   503 			{

   504 			// for a base instance, need to set a default implementation

   505 			// even for missing data

   506 			(*pImpl)->SetDefinition(CdlTkUtil::ShortToHexString(0) + ",\t// " + KDefinitionNotDefined);

   507 			

   508 			// preliminary implementation of "blank" implementation. cdl engine searches to ensure that

   509 			// all implementations are not NULL. So this will satisfy that test. However, if any of the 

   510 			// methods are called, there will be an access violation, which will cause a panic

   511 			// this will be a successful guide to implementers not to call the API when the wrong layout

   512 			// pack is installed.

   513 			string definition = "(" + iface.NamespaceName() + "::" + api.PointerType() + ")((void*)4), // LAYOUT NOT DEFINED FOR THIS INSTANCE";

   514 			(*pImpl)->SetPointerReference(definition); 

   515 			}

   516         else if(aNonCompleteInstance)

   517             {

   518 			// for a base instance, need to set a default implementation

   519 			// even for missing data

   520 			(*pImpl)->SetDefinition(CdlTkUtil::ShortToHexString(0) + ",\t// " + KDefinitionNotDefined);

   521 

   522             // but we need the pointer to be null so that CdlEngine falls through the layer below

   523 			string definition =  "0, // " + iface.NamespaceName() + "::" + api.PointerType();

   524 			(*pImpl)->SetPointerReference(definition); 

   525             }

   526         else

   527 			{

   528 			// Initially set definition that will not compile in the resulting code.

   529 			// This will alert the programmer to missing layout data.

   530 			(*pImpl)->SetDefinition(KDefinitionNotSet);

   531 			}

   532 		}

   533 	}

   534 

   535 CMLCompDataInstOpt::~CMLCompDataInstOpt()

   536 	{

   537 	delete iInstance;

   538 	for (CMLCompDataInstOptImpls::iterator pImpl = iImpls.begin(); pImpl != iImpls.end(); ++pImpl)

   539 		delete *pImpl;

   540 	for (pImpl = iTableImpls.begin(); pImpl != iTableImpls.end(); ++pImpl)

   541 		delete *pImpl;

   542 	}

   543 

   544 void CMLCompDataInstOpt::Process(const string& aFirstInstName)

   545 	{

   546 	iLayout->Compile();

   547 

   548 	for (TMLCompData::iterator pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)

   549 		{

   550 		ProcessLines(**pTab);

   551 		}

   552 

   553 	for (pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)

   554 		{

   555 		ProcessTables(**pTab);

   556 		}

   557 

   558 	// update the base offset to include all the data added, including reserving space for the tables

   559 	UpdateBaseOffset();

   560 

   561 	// with the correct base offset, the definitions can be updated

   562 	UpdateLineImpls();

   563 

   564 	for (pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)

   565 		{

   566 		// now that the rest of the data is stable, we can add the tables at the end

   567 		UpdateTables(**pTab);

   568 		}

   569 

   570 	SetGenericAPI(SCompDataImplFunc::EGenericComponentType, KFuncGetComponentTypeById);

   571 	SetGenericAPI(SCompDataImplFunc::EGenericParamLimits, KFuncGetParamLimitsById);

   572 	SetGenericAPI(SCompDataImplFunc::EGenericWindowComponent, KFuncGetWindowComponentById);

   573 	SetGenericAPI(SCompDataImplFunc::EGenericTextComponent, KFuncGetTextComponentById);

   574 	

   575 	SetExtraCpp(aFirstInstName);

   576 	OutputStats();

   577 	}

   578 

   579 void CMLCompDataInstOpt::WriteInstance()

   580 	{

   581 	CCdlTkWriteInstance writer(*iInstance);

   582 	writer.Process();

   583 	}

   584 

   585 void CMLCompDataInstOpt::ProcessLines(TMLCompDataTable& aTable)

   586 	{

   587 	for (TMLCompDataTable::iterator pLine = aTable.begin(); pLine != aTable.end(); ++pLine)

   588 		{

   589 		ProcessLine(**pLine);

   590 		}

   591 	}

   592 

   593 void CMLCompDataInstOpt::ProcessTables(TMLCompDataTable& aTable)

   594 	{

   595 	int line = 0;

   596 	for (TMLCompDataTable::iterator pLine = aTable.begin(); pLine != aTable.end(); ++pLine)

   597 		{

   598 		for (TMLCompDataTable::TMLCompDataSubTables::const_iterator pSub = aTable.iSubTables.begin(); pSub != aTable.iSubTables.end(); ++pSub)

   599 			{

   600 			TMLCompDataTable::TMLCompDataSubTable& sub = **pSub;

   601 			int last = *(sub.rbegin());

   602 			if(line == last)

   603 				AddTableToInstance(aTable, sub, 0);

   604 			}

   605 		line++;

   606 		}

   607 	}

   608 

   609 void CMLCompDataInstOpt::ProcessLine(TMLCompDataLine& aLine)

   610 	{

   611 	string apiName = MLCompDataToCdl::LineApiName(aLine);

   612 	if (!HasApi(apiName))

   613 		return;

   614 

   615 	ProcessLineApi(aLine, FindImp(apiName));

   616 	}

   617 

   618 void CMLCompDataInstOpt::ProcessLineApi(TMLCompDataLine& aLine, CCdlTkImplementation& aImpl)

   619 	{

   620 	string lineName = MLCompDataToCdl::LineApiName(aLine);

   621 

   622 	CMLCompDataLineInstOptImpl* newImpl = new CMLCompDataLineInstOptImpl(&aLine, &aImpl);

   623 	iImpls.push_back(newImpl);

   624 

   625 	// always set the new line data

   626 	SetNewLineData(*newImpl);

   627 

   628 	// if we can find the new line data in the aggregated data, point to that instead

   629 	int foundIndex = iInstances.FindSimilarBytes(newImpl, iBaseOffset);

   630 	if(foundIndex >= 0)

   631 		{

   632 		newImpl->iByteCodeIndex = foundIndex;

   633 		newImpl->iIsRedirectedToExactCopy = true;

   634 		}

   635 	else

   636 		{

   637 		iInstances.AddImpl(newImpl);

   638 		}

   639 

   640 	SetLineFunc(*newImpl);

   641 

   642 	// only add parameter limits if the line is not simple

   643 	// and we must add the param limits after the actual impl, so that we can find it!

   644 	bool needsParamLimits = aLine.NeedsOptions() || aLine.NeedsCols() || aLine.NeedsRows();

   645 	if(needsParamLimits)

   646 		{

   647 		AddParamLimits(aLine, aLine.NeedsOptions());

   648 		}

   649 	}

   650 

   651 void CMLCompDataInstOpt::UpdateBaseOffset()

   652 	{

   653 	// have to account for this instance's tables

   654 	int tablesSize(0);

   655 	for(CMLCompDataInstOptImpls::iterator pTableImpl = iTableImpls.begin(); pTableImpl != iTableImpls.end(); ++pTableImpl)

   656 		{

   657 		CMLCompDataInstOptImpl* impl = *pTableImpl;

   658 		tablesSize += impl->iBytes.size();

   659 		}

   660 

   661 	int origByteStreamSize = iInstances.ByteStreamSize() + tablesSize;

   662 

   663 	// repeat until base offset stabilizes

   664 	iBaseOffset = max(0, origByteStreamSize - KAddressableBytecodedData);

   665 	int newBaseOffset = iBaseOffset;

   666 	int byteCodeSizeDelta(0);

   667 	do

   668 		{

   669 		iBaseOffset = newBaseOffset;

   670 		for(CMLCompDataInstOptImpls::iterator pImpl = iImpls.begin(); pImpl != iImpls.end(); ++pImpl)

   671 			UpdateLine(**pImpl, byteCodeSizeDelta);

   672 		newBaseOffset = max(0, origByteStreamSize + byteCodeSizeDelta - KAddressableBytecodedData);

   673 		}

   674 	while(iBaseOffset != newBaseOffset);

   675 	}

   676 

   677 void CMLCompDataInstOpt::UpdateLine(CMLCompDataInstOptImpl& aImpl, int& aByteCodeSizeDelta)

   678 	{

   679 	if(aImpl.iIsRedirectedToExactCopy && aImpl.iByteCodeIndex < iBaseOffset)

   680 		{

   681 		// when we encoded the impls, we found a match in an area which now

   682 		// turns out to be before the base offset (i.e. outside the addressable range).

   683 

   684 		// first of all check in case we've already made another copy close by

   685 		int foundIndex = iInstances.FindSimilarBytes(&aImpl, iBaseOffset);

   686 		if(foundIndex >= 0)

   687 			{

   688 			aImpl.iByteCodeIndex = foundIndex;

   689 			}

   690 		else

   691 			{

   692 			// add its bytecodes to the end

   693 			aImpl.iIsRedirectedToExactCopy = false;

   694 			iInstances.AddImpl(&aImpl);

   695 			aByteCodeSizeDelta += aImpl.iBytes.size();

   696 			}

   697 		}

   698 	}

   699 

   700 

   701 void CMLCompDataInstOpt::UpdateLineImpls()

   702 	{

   703 	for(CMLCompDataInstOptImpls::iterator pImpl = iImpls.begin(); pImpl != iImpls.end(); ++pImpl)

   704 		UpdateLineImplDefn(**pImpl);

   705 	}

   706 

   707 void CMLCompDataInstOpt::UpdateLineImplDefn(CMLCompDataInstOptImpl& aImpl)

   708 	{

   709 	if(!CheckByteCodeIndexInRange(aImpl.iByteCodeIndex))

   710 		throw GeneralErr(aImpl.iName + " in interface " + iInterface.FileName());

   711 	// the base offset has been updated, so all definitions must be refreshed

   712 	int adjustedIndex = aImpl.iByteCodeIndex - iBaseOffset;

   713 	aImpl.iImpl->SetDefinition(DefinitionString(aImpl.iByteCodeIndex, aImpl.iName));

   714 	UpdateParamLimits(aImpl.iName); 

   715 	}

   716 

   717 void CMLCompDataInstOpt::UpdateTables(TMLCompDataTable& aTable)

   718 	{

   719 	// regenerate the byte code indices, in case they have changed

   720 	int line = 0;

   721 	for (TMLCompDataTable::iterator pLine = aTable.begin(); pLine != aTable.end(); ++pLine)

   722 		{

   723 		for (TMLCompDataTable::TMLCompDataSubTables::const_iterator pSub = aTable.iSubTables.begin(); pSub != aTable.iSubTables.end(); ++pSub)

   724 			{

   725 			TMLCompDataTable::TMLCompDataSubTable& sub = **pSub;

   726 			int last = *(sub.rbegin());

   727 			if(line == last)

   728 				{

   729 				string tableName = MLCompDataToCdl::SubTableApiName(sub);

   730 				CMLCompDataInstOptImpl* impl = FindSimilarImpl(iTableImpls, FindImp(tableName));

   731 				UpdateTableInstance(aTable, sub, impl);

   732 				}

   733 			}

   734 		line++;

   735 		}

   736 	}

   737 

   738 void CMLCompDataInstOpt::SetNewLineData(CMLCompDataLineInstOptImpl& aImpl)

   739 	{

   740 	aImpl.iBytes.clear();	

   741 

   742 	TMLCompDataLine& line = *aImpl.iLine;

   743 	aImpl.iComment = string("for line: ");

   744 	aImpl.iName = MLCompDataToCdl::LineApiName(line);

   745 

   746 	// handle mirroring order

   747 	bool mirrored = false;

   748 	if(line.iParentTable) // we know top table can't be mirrored

   749 		mirrored = line.iParentTable->iTables->iCanBeMirror;

   750 	const string* outputOrder =  mirrored ? 

   751 		KCompDataGraphicOutputOrderMirrored : KCompDataGraphicOutputOrder;

   752 	int outputSize = KCompDataGraphicOutputOrderSize;

   753 	if (line.iType == TMLCompDataLine::ETextComponent)

   754 		{

   755 		outputOrder = mirrored ? 

   756 			KCompDataTextOutputOrderMirrored : KCompDataTextOutputOrder;

   757 		outputSize = KCompDataTextOutputOrderSize;

   758 		}

   759 	vector<string> cellOrder(outputOrder, outputOrder + outputSize);

   760 

   761 	// we are currently storing variety as max allowed value, but it's a zero based index

   762 	int numVarieties = line.MaxVariety() + 1;

   763 

   764 	// we will be storing all of the rows and cols, even if the rows and cols limits are lower

   765 	int totalMaxCols = numVarieties * line.NumCols();

   766 	int totalMaxRows = numVarieties * line.NumRows();

   767     int totalMax = totalMaxCols > totalMaxRows ? totalMaxCols : totalMaxRows;

   768 

   769 	// initialize the temporary bytestream, and the index map

   770 	vector<char> tempBytes;

   771 	IndexMap indexMap;

   772 

   773 	// fill in the temp byte stream and the index map for each cell

   774 	OptimizeNewLineData(aImpl, indexMap, tempBytes, cellOrder, mirrored, totalMax, numVarieties);

   775 

   776 	// encode the index map

   777 	SetNewLineParamData(aImpl, indexMap, totalMax, numVarieties);

   778 

   779 	// finally copy the temp byte stream onto the end of the real encoded byte stream

   780 	copy(tempBytes.begin(), tempBytes.end(), back_inserter(aImpl.iBytes));

   781 	}

   782 

   783 void CMLCompDataInstOpt::SetNewLineParamData(CMLCompDataLineInstOptImpl& aImpl, IndexMap& aIndexMap, int aTotalMax, int aNumVarieties)

   784 	{

   785 	// only set parameter data if the line is not simple

   786 	TMLCompDataLine& line = *aImpl.iLine;

   787 	

   788 	bool needsHeader = line.NeedsOptions() || line.NeedsCols() || line.NeedsRows();

   789 

   790 	int typeBitfield = line.iType << 1;

   791 	if(needsHeader)

   792 		{

   793 		typeBitfield |= 1;

   794 		}

   795 	

   796 	aImpl.iBytes.push_back(typeBitfield);

   797 

   798 	if(needsHeader)

   799 		{

   800 		// we can just dump the number of varieties, this will be used by the limits API

   801 		// and we can also them to calculate value indices within a cell when decoding

   802 		aImpl.iBytes.push_back(aNumVarieties);

   803 		}

   804 

   805 	//  count the number of cells that are complex

   806 	char numMultiValues = aIndexMap.size();

   807 	if(needsHeader)

   808 		{

   809 		aImpl.iBytes.push_back(numMultiValues);

   810 		}

   811 	else

   812 		{

   813 		// we didn't think we needed a header, so there should be no complex cells!

   814 		if (numMultiValues > 0)

   815 			throw GeneralErr("complex cells detected in simple line");

   816 		}

   817 

   818 	// for each complex cell, encode the bitfield and the count

   819 	for(IndexMap::iterator pIndex = aIndexMap.begin(); pIndex != aIndexMap.end(); ++pIndex)

   820 		{

   821 		int count = pIndex->first;

   822 		int index = pIndex->second;

   823 		EncodeValue(aImpl.iBytes, index);

   824 		EncodeValue(aImpl.iBytes, count);

   825 		}

   826 	}

   827 

   828 void CMLCompDataInstOpt::OptimizeNewLineData(

   829 	CMLCompDataLineInstOptImpl& aImpl, 

   830 	IndexMap& aIndexMap, 

   831 	vector<char>& aTempBytes,

   832 	const vector<string>& aOutputOrder,

   833 	bool aMirrored,

   834 	int aTotalMax, 

   835 	int aNumVarieties)

   836 	{

   837 	vector<ParamLimitVarieties> paramLimits;

   838 	TMLCompDataLine& line = *aImpl.iLine;

   839 

   840 	// start by extracting the row and column data. 

   841 	// we can optimize the stored format along with the rest of the data

   842 	// so no need to optimize it yet

   843 	for(int cell = 0; cell < 2; cell++)

   844 		{

   845 		string cellName = aOutputOrder[cell];

   846 		ParamLimitVarieties nextLimits;

   847 		TMLCompDataValues& values = line[cellName];

   848 		for(int varietyIndex = 0; varietyIndex < aNumVarieties; varietyIndex++)

   849 			{

   850 			TMLCompDataZoomLevels& zoomLevels = values[varietyIndex];

   851 			TMLCompDataCalcs* calcs = &(zoomLevels[iZoomLevel]);

   852 			if(!calcs->size())

   853 				calcs = &(zoomLevels[EAknUiZoomNormal]);

   854 			int value = CdlTkUtil::ParseInt((*calcs)[0]);

   855 			nextLimits.push_back(value);

   856 			}

   857 		paramLimits.push_back(nextLimits);

   858 		}

   859 

   860 	// calculate the number of values

   861 	bool needsHeader = line.NeedsOptions() || line.NeedsCols() || line.NeedsRows();

   862 	unsigned int nextCellFlag = 1;	// bit flag for the next cell, note it can get bigger than a char

   863 	for (cell = 0; cell < aOutputOrder.size(); cell++)

   864 		{

   865 		string cellName = aOutputOrder[cell];

   866 		TMLCompDataValues::TCompDataCellType type = TMLCompDataValues::Type(cellName);

   867 		if(!needsHeader && type == TMLCompDataValues::ECellTypeParamLimit)

   868 			{

   869 			// if we don't need header, then don't output the param limits values

   870 			// although we'll still use them internally

   871 			continue;

   872 			}

   873 

   874 		int paramLimitsIndex = TMLCompDataValues::Type(cellName) == TMLCompDataValues::ECellTypeCol ? 0 : 1; // if it's not a row or col, it doesn't matter what param limits are used.

   875 		TMLCompDataValues& values = line[cellName];

   876 		int numValues = 0;

   877 		if(type == TMLCompDataValues::ECellTypeCol || type == TMLCompDataValues::ECellTypeRow)

   878 			{

   879 			ParamLimitVarieties& nextLimits = paramLimits[paramLimitsIndex];

   880 			numValues = std::accumulate(nextLimits.begin(), nextLimits.end(), 0);

   881 			}

   882 		else

   883 			{

   884 			numValues = aNumVarieties;

   885 			}

   886 

   887 		bool mirrorJustification = (aMirrored && cellName == KCellNameJustification);

   888 		OptimizeNewLineCellData(aIndexMap, aTempBytes, values, nextCellFlag, numValues, aNumVarieties, paramLimits[paramLimitsIndex], cellName, mirrorJustification);

   889 		}

   890 	}

   891 

   892 void CMLCompDataInstOpt::OptimizeNewLineCellData(

   893 	IndexMap& aIndexMap, 

   894 	vector<char>& aTempBytes, 

   895 	TMLCompDataValues& aValues, 

   896 	unsigned int& aNextCell, 

   897 	int aTotalParams,

   898 	int aNumVarieties, 

   899 	CMLCompDataInstOpt::ParamLimitVarieties& aParamLimitVarieties, 

   900 	string cellName,

   901 	bool aMirrorJustification)

   902 	{

   903 	// build up the values for each variety 

   904 	// if the valid values for each variety are the same, then we can store them once only

   905 	// in which case there will be as many values as the variety with the largest number of values

   906 	vector<string> optimizedValues; 

   907 

   908 	// also build up the found valid values in case we can't optimize

   909 	vector<string> foundValues; 

   910 

   911 	bool optimizeVarieties = true;

   912 	bool optimizeCalcs = true;

   913 	int numCalcs = 0;

   914 	int* largestParamLimitPtr = max_element(aParamLimitVarieties.begin(), aParamLimitVarieties.end());

   915 	int largestParamLimit = largestParamLimitPtr != aParamLimitVarieties.end() ? *largestParamLimitPtr : 0;

   916 	

   917 	// in the case of there being no calcs at all, we don't want to be optimizing,

   918 	// in order to avoid wasted flags.

   919 	if(largestParamLimit == 1)

   920 		optimizeCalcs = false;

   921 

   922 	TMLCompDataValues::TCompDataCellType type = TMLCompDataValues::Type(cellName);

   923 	bool isColRow = (type == TMLCompDataValues::ECellTypeCol ||	type == TMLCompDataValues::ECellTypeRow);

   924 

   925 	// only go up to the max variety, as any data past that may be from a spurious merged instance

   926 	for(int varietyIndex = 0; varietyIndex < aNumVarieties; varietyIndex++)

   927 		{

   928 		TMLCompDataZoomLevels& zoomLevels = aValues[varietyIndex];

   929 		TMLCompDataCalcs* calcs = &(zoomLevels[iZoomLevel]);

   930 		if(!calcs->size())

   931 			calcs = &(zoomLevels[EAknUiZoomNormal]);

   932 		numCalcs = calcs->size();

   933 		string value;

   934 		vector<string> foundCalcs; 

   935 		int paramLimit = aParamLimitVarieties[varietyIndex];

   936 		if(numCalcs == 0)

   937 			{

   938 			if(varietyIndex == 0)

   939 				optimizedValues.push_back(value);

   940 			if(varietyIndex > 0 && !(optimizedValues[0].empty()))

   941 				optimizeVarieties = false;

   942 			foundCalcs.push_back(value);

   943 			}

   944 		else

   945 			{

   946 			for(int index = 0; index < numCalcs; index++)

   947 				{

   948 				bool needToCheckIndexValidity = !isColRow || (index < paramLimit);

   949 				value = (*calcs)[index];

   950 				value = aMirrorJustification ? TMLCompDataValues::MirrorJustificationValue(value) : value;

   951 

   952 				if(index >= optimizedValues.size() && index < largestParamLimit) // index is zero based, size is quantity

   953 					{

   954 					// store the first valid value for a given index that we find.

   955 					// note that this will pick up additional values in subsequent varieties

   956 					optimizedValues.push_back(value);

   957 					}

   958 				else if(needToCheckIndexValidity && value != optimizedValues[index]) 

   959 					{

   960 					// so if it doesn't match, we can't optimize

   961 					optimizeVarieties = false;

   962 					}

   963 

   964 				// collect the valid found values as we go, in case we aren't able to optimize

   965 				if(needToCheckIndexValidity)

   966 					{

   967 					foundCalcs.push_back(value);

   968 					}

   969 				}

   970 			}

   971 		if(isColRow)

   972 			{

   973 			int found = foundCalcs.size();

   974 			if(!found)

   975 				{

   976 				foundCalcs.push_back(string());

   977 				found++;

   978 				}

   979 			if(found > 1)

   980 				{

   981 				optimizeCalcs = false;

   982 				}

   983 			}

   984 		else

   985 			{

   986 			optimizeCalcs = false;

   987 			}

   988 		copy(foundCalcs.begin(), foundCalcs.end(), back_inserter(foundValues));

   989 		}

   990 

   991 	if(optimizeVarieties && isColRow)

   992 		{

   993 		// now that we know the optimized values, fill missing values by repeating the last one.

   994 		// but if we're optimizing the calcs, then we don't want to expand them after all

   995 		if(!optimizeCalcs)

   996 			{

   997 			int optimal = optimizedValues.size();

   998 			string value = optimal > 0 ? optimizedValues[optimal-1] : string();

   999 			for(; optimal < largestParamLimit; optimal++)

  1000 				{

  1001 				optimizedValues.push_back(value);

  1002 				}

  1003 			}

  1004 		}

  1005 

  1006 	if(optimizeVarieties && aNumVarieties == 1)

  1007 		{

  1008 		optimizeVarieties = false;

  1009 		}

  1010 

  1011 	vector<string>& valuesToEncode = optimizeVarieties ? optimizedValues : foundValues;

  1012 	EncodeNewLineCellData(aIndexMap, aTempBytes, valuesToEncode, aNextCell, aTotalParams, optimizeVarieties, optimizeCalcs);

  1013 	}

  1014 

  1015 void CMLCompDataInstOpt::EncodeNewLineCellData(

  1016 	IndexMap& aIndexMap, 

  1017 	vector<char>& aTempBytes, 

  1018 	vector<string>& aValuesToEncode, 

  1019 	unsigned int& aNextCell,

  1020 	int aTotalMax,

  1021 	bool aOptimizeVarieties,

  1022 	bool aOptimizeCalcs)

  1023 	{

  1024 	// encode the actual data into the temporary bytestream

  1025 	int numOptimizedVals = aValuesToEncode.size();

  1026 	if(numOptimizedVals > 0)

  1027 		{

  1028 		for(vector<string>::iterator pString = aValuesToEncode.begin(); pString != aValuesToEncode.end(); ++pString)

  1029 			{

  1030 			EncodeValue(aTempBytes, *pString);

  1031 			}

  1032 		}

  1033 	else

  1034 		{

  1035 		EncodeValue(aTempBytes, "");

  1036 		}

  1037 

  1038 	if(numOptimizedVals > aTotalMax)

  1039 		throw GeneralErr("bad index in indexMap");

  1040 	

  1041 	// if there is only one value stored, we can make a further optimization

  1042 	// as we know that all values must be the same, however they are stored

  1043 	// so in that case, don't store an index map entry

  1044 	if(numOptimizedVals > 1)

  1045 		{

  1046 		// update the index map, 

  1047 		// put the flags at the right hand side, to avoid it becoming multi-byte in general

  1048 		int optimizeVarietiesMask = (aOptimizeVarieties ? 1 : 0);

  1049 		int optimizeCalcsMask = (aOptimizeCalcs ? 1 : 0) << 1;

  1050 		int numValsMask = (numOptimizedVals) << 2;

  1051 		int indexField = (numValsMask | optimizeCalcsMask | optimizeVarietiesMask);

  1052 		aIndexMap[indexField] |= aNextCell;

  1053 		}

  1054 	aNextCell = aNextCell << 1;

  1055 	}

  1056 

  1057 void CMLCompDataInstOpt::CountApiParams(CCdlTkImplementation& aApi, int& aParams)

  1058 	{

  1059 	aParams = 0;

  1060 	const CCdlTkApiParams& params = aApi.Api().AsFunc().Params();

  1061 	for (CCdlTkApiParams::const_iterator pParam = params.begin(); pParam != params.end(); ++pParam)

  1062 		{

  1063 		if (pParam->Type() == KTypeInt) // is it a cell index parameter

  1064 			aParams++;

  1065 		}

  1066 	}

  1067 

  1068 void CMLCompDataInstOpt::ValidateRequiredParams(string aApiName, CCdlTkApiParams& aParams, bool aOption, bool aColumn, bool aRow)

  1069 	{

  1070 	// check that data matches api

  1071 	bool matches = true;

  1072 	matches &= ((aOption) == (aParams.FindByName(KParamOptionIndex) != aParams.end()));

  1073 	matches &= ((aColumn) == (aParams.FindByName(KParamColIndex) != aParams.end()));

  1074 	matches &= ((aRow) == (aParams.FindByName(KParamRowIndex) != aParams.end()));

  1075 	if(!matches)

  1076 		throw CdlTkAssert(string("layout data does not match CDL API : ") + aApiName);

  1077 	}

  1078 

  1079 void CMLCompDataInstOpt::SetGenericFunc(CMLCompDataInstOptImpl& aImpl, SCompDataImplFunc::TFuncType aType)

  1080 	{

  1081 	CCdlTkFunctionApi& api = const_cast<CCdlTkFunctionApi&>(aImpl.iImpl->Api().AsFunc());

  1082 	CCdlTkApiParams& params = api.Params();

  1083 

  1084 	SCompDataImplFunc& func = AddImplFunc(aType, params);

  1085 	aImpl.iImpl->SetPointerReference(func.iPtrRef);

  1086 	}

  1087 

  1088 void CMLCompDataInstOpt::SetLineFunc(CMLCompDataLineInstOptImpl& aImpl)

  1089 	{

  1090 	SCompDataImplFunc::TFuncType type = SCompDataImplFunc::EWindowLine;

  1091 	if (aImpl.iLine->iType == TMLCompDataLine::ETextComponent)

  1092 		{

  1093 		type = SCompDataImplFunc::ETextLine;

  1094 		}

  1095 	string name = aImpl.iImpl->Name();

  1096 

  1097 	// look up the api to see whether we need the params

  1098 	CCdlTkFunctionApi& api = const_cast<CCdlTkFunctionApi&>(aImpl.iImpl->Api().AsFunc());

  1099 	CCdlTkApiParams& params = api.Params();

  1100 	ValidateRequiredParams(

  1101 		name, 

  1102 		params, 

  1103 		iAllParams || aImpl.iLine->NeedsOptions(), 

  1104 		iAllParams || aImpl.iLine->NeedsCols(), 

  1105 		iAllParams || aImpl.iLine->NeedsRows());

  1106 	SCompDataImplFunc& func = AddImplFunc(type, params);

  1107 	aImpl.iImpl->SetPointerReference(func.iPtrRef);

  1108 	}

  1109 

  1110 void CMLCompDataInstOpt::SetSubTableFunc(CMLCompDataSubTableInstOptImpl& aImpl)

  1111 	{

  1112 	TMLCompDataTable& table = *(aImpl.iTable);

  1113 	TMLCompDataTable::TMLCompDataSubTable& subTable = *(aImpl.iSubTable);

  1114 	TMLCompDataLine& line= *(table[subTable[0]]);

  1115 

  1116 	SCompDataImplFunc::TFuncType type = SCompDataImplFunc::EWindowTable;

  1117 

  1118 	if (line.iType == TMLCompDataLine::ETextComponent)

  1119 		{

  1120 		type = SCompDataImplFunc::ETextTable;

  1121 		}

  1122 	string name = aImpl.iImpl->Name();

  1123 

  1124 	CCdlTkFunctionApi& api = const_cast<CCdlTkFunctionApi&>(aImpl.iImpl->Api().AsFunc());

  1125 	CCdlTkApiParams& params = api.Params();

  1126 

  1127 	string debug;

  1128 	for(CCdlTkApiParams::iterator pParam = params.begin(); pParam != params.end(); ++pParam)

  1129 		debug = pParam->Name();

  1130 

  1131 	ValidateRequiredParams(

  1132 		name, 

  1133 		params, 

  1134 		iAllParams || subTable.iNeedsOption,