diff -r 000000000000 -r f58d6ec98e88 aknlayoutcompiler/src/CppWriter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/aknlayoutcompiler/src/CppWriter.cpp	Thu Dec 17 09:14:18 2009 +0200
@@ -0,0 +1,709 @@
+/*
+* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*    
+*
+*/
+
+
+#include "CppWriter.h"
+#include "layoutcompilererr.h"
+#include "CodeGenConsts.h"
+#include "UsefulDefinitions.h"
+
+#include <cdlcompilertoolkit/cdltkutil.h>
+
+#include <fstream>
+#include <algorithm>
+#include <iostream> // !!! for debug output only
+
+using namespace CdlCompilerToolkit;
+
+string whiteSpace = " \t\r\n";
+
+const string KTextOutputOrder[] = {"C", "l", "r", "B", "W", "J", "Font"};
+const string KTextOutputOrderMirrored[] = {"C", "r", "l", "B", "W", "J", "Font"};
+const int KTextOutputOrderSize = ARRAY_LEN(KTextOutputOrder);
+
+const string KWindowOutputOrder[] = {"C", "l", "t", "r", "b", "W", "H"};
+const string KWindowOutputOrderMirrored[] = {"C", "r", "t", "l", "b", "W", "H"};
+const int KWindowOutputOrderSize = ARRAY_LEN(KWindowOutputOrder);
+
+// class TValuesCppWriter
+void TValuesCppWriter::WriteCpp(ostream& aCpp)
+	{
+	for (TValues::const_iterator it = iValues.begin(); it != iValues.end(); ++it)
+		{
+		if (it != iValues.begin())
+			aCpp << ", ";
+		aCpp << TValues::CppValue(*it);
+		}
+	}
+
+
+// class TLayoutLineCppWriter
+
+void TLayoutLineCppWriter::WriteCpp(ostream& aCpp)
+	{
+	// write line structure
+	WriteLineClassName(aCpp);
+	aCpp << Name() << " = { ";
+	WriteCppData(aCpp);
+	aCpp << " };" << endl << endl;
+	}
+
+
+void TLayoutLineCppWriter::WriteCppData(ostream& aCpp)
+	{
+	if (iLine.iNeedsIndex)
+		WriteVarCppData(aCpp);
+	else
+		WriteFixedCppData(aCpp);
+	}
+
+
+int TLayoutLineCppWriter::WriteParamList(ostream& aLag, const vector<string>& aParams)
+	{
+	int written = 0;
+	if (aParams.size() > 0)
+		{
+		written = 2*aParams.size();
+		aLag << "(";
+		for (vector<string>::const_iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)
+			{
+			if (pParam != aParams.begin())
+				aLag << ", ";
+			aLag << *pParam;
+			written += pParam->size();
+			}
+		aLag << ")";
+		}
+	return written;
+	}
+
+int TLayoutLineCppWriter::ValCount()
+	{
+	int count = 0;
+	for (TLayoutLine::const_iterator pVal = iLine.begin(); pVal != iLine.end(); ++pVal)
+		{
+		if (TLayoutTable::IsValueColumn(pVal->first))
+			count += pVal->second.size();
+		}
+	return count;
+	}
+
+
+// class TWindowLineCppWriter
+
+string TWindowLineCppWriter::Name()
+	{
+	if (iLine.iIsUnique)
+		return CdlTkUtil::ToCpp(iLine.Name());
+	else
+		return CdlTkUtil::ToCpp(iLine.TableName());
+	}
+
+void TWindowLineCppWriter::WriteLineClassName(ostream& aCpp)
+	{
+	if (iLine.iNeedsIndex)
+		{
+		aCpp << "const SVarWindowLine<" << ValCount() << "> ";
+		}
+	else
+		{
+		aCpp << "const SFixedWindowLine ";
+		}
+	}
+
+void TWindowLineCppWriter::WriteVarCppData(ostream& aCpp)
+	{
+	aCpp << " { "; // suppress the first offset
+
+	int offset = 0;
+	for (int i=0; i<KWindowOutputOrderSize-1; i++) // Last offset is not used
+		{
+		offset += iLine[KWindowOutputOrder[i]].size();
+		if ( i != 0 ) 
+			aCpp << ", ";
+		aCpp << offset;
+		}
+
+	aCpp << " }, { ";
+
+	WriteFixedCppData(aCpp);
+
+	aCpp << " }";
+	}
+
+void TWindowLineCppWriter::WriteFixedCppData(ostream& aCpp)
+	{
+	for (int i=0; i<KWindowOutputOrderSize; i++)
+		{
+		if (i>0)
+			aCpp << ", ";
+		TValuesCppWriter writer(iLine[KWindowOutputOrder[i]]);
+		writer.WriteCpp(aCpp);
+		}
+	}
+
+void TWindowLineCppWriter::FillParamLists(vector<string>& aDef, vector<string>& aCtor)
+	{
+	if (iLine.iNeedsP)
+		{
+		aDef.push_back(KParamParentRect);
+		aCtor.push_back(KParamParentRect);
+		}
+
+	if (iLine.iNeedsIndex)
+		{
+		aCtor.push_back(CdlTkUtil::IntToString(iLine.iIsMirroredHorizontally));
+
+		for (int i=0; i<KWindowOutputOrderSize; i++)
+			{
+			// need to worry about parameter mirroring here. The problem is that 
+			// the macro needs to have a fixed parameter ordering, but the parameters
+			// might vary between variants, therefore the order of mirrored parameters 
+			// may vary, e.g. (l, t) becomes (t, r) etc. Solution is to swap l and r if the line is mirrored
+			// just for the macro definition (not for the ctor). 
+			string name = KWindowOutputOrder[i];
+			string nameMirrored = KWindowOutputOrderMirrored[i];
+
+			const TValues& defValues = iLine[iLine.iIsMirroredHorizontally ? nameMirrored : name];
+			if (defValues.iNeedsIndex)
+				{
+				string param = CdlTkUtil::ToCpp(defValues.ParamName());
+				if (find(aDef.begin(), aDef.end(), param) == aDef.end()) // param Only written once to Macro
+					{
+					aDef.push_back(param);
+					}
+				}
+
+			const TValues& ctorValues = iLine[name];
+			if (ctorValues.iNeedsIndex)
+				{
+				string param = CdlTkUtil::ToCpp(ctorValues.ParamName());
+				aCtor.push_back(param);
+				}
+			else
+				{
+				aCtor.push_back("0");
+				}
+			}
+		}
+	}
+
+void TWindowLineCppWriter::WriteMacro(ostream& aLag)
+	{
+	vector<string> def_params;
+	vector<string> ctor_params;
+	ctor_params.push_back(CdlTkUtil::IntToString(iLine.iGlobalIndex));
+
+	FillParamLists(def_params, ctor_params);
+
+	aLag << "#define AKN_LAYOUT_WINDOW_" << Name();
+	WriteParamList(aLag, def_params);
+	aLag << "\t" << KTypeWindowLineLayout;		
+	WriteParamList(aLag, ctor_params);
+	aLag << endl;
+	}
+
+
+// class TTextLineCppWriter
+
+string TTextLineCppWriter::Name()
+	{
+	return CdlTkUtil::ToCpp(iLine.TableName());
+	}
+
+void TTextLineCppWriter::FillParamLists(vector<string>& aDef, vector<string>& aCtor)
+	{
+	iBaseLineVariation = false;
+
+	if (iLine.iNeedsP)
+		{
+		aDef.push_back(KParamParentRect);
+		aCtor.push_back(KParamParentRect);
+		}
+
+	if (iLine.iNeedsIndex)
+		{
+		aCtor.push_back(CdlTkUtil::IntToString(iLine.iIsMirroredHorizontally));
+
+		for (int i=0; i<KTextOutputOrderSize; i++)
+			{
+			// need to worry about parameter mirroring here. The problem is that 
+			// the macro needs to have a fixed parameter ordering, but the parameters
+			// might vary between variants, therefore the order of mirrored parameters 
+			// may vary, e.g. (l, t) becomes (t, r) etc. Solution is to swap l and r if the line is mirrored
+			// just for the macro definition (not for the ctor). 
+			string name = KTextOutputOrder[i];
+			string nameMirrored = KTextOutputOrderMirrored[i];
+
+			const TValues& defValues = iLine[iLine.iIsMirroredHorizontally ? nameMirrored : name];
+			if (defValues.iNeedsIndex)
+				{
+				string param = CdlTkUtil::ToCpp(defValues.ParamName());
+				if (find(aDef.begin(), aDef.end(), param) == aDef.end()) // uniqueness check
+					{
+					aDef.push_back(param);
+					}
+
+				// record whether some of the variation comes from the Baseline column
+				if ( defValues.iName == "B")
+					iBaseLineVariation = true;	
+				}
+
+			const TValues& ctorValues = iLine[name];
+			if (ctorValues.iNeedsIndex)
+				{
+				string param = CdlTkUtil::ToCpp(ctorValues.ParamName());
+				aCtor.push_back(param);
+				}
+			else
+				{
+				aCtor.push_back("0");
+				}
+			}
+		}
+	}
+
+void TTextLineCppWriter::WriteMacro(ostream& aLag)
+	{
+	vector<string> def_params;
+	vector<string> ctor_params;
+	ctor_params.push_back(CdlTkUtil::IntToString(iLine.iGlobalIndex));
+
+	FillParamLists(def_params, ctor_params);
+
+	aLag << "#define AKN_LAYOUT_TEXT_" << Name();
+	WriteParamList(aLag, def_params);
+	aLag << "\t" << KTypeTextLineLayout;
+	WriteParamList(aLag, ctor_params);
+	aLag << endl;
+
+// Also write out a multiline_text if there are more than one Baselines supplied.  Number of lines is always user-supplied
+	vector<string> multiline_def_params;
+	vector<string> multiline_ctor_params;
+
+	if ( iBaseLineVariation )
+		{
+		multiline_ctor_params.push_back(CdlTkUtil::IntToString(iLine.iGlobalIndex));
+
+		if (iLine.iNeedsP)
+			{
+			multiline_def_params.push_back(KParamParentRect);
+			multiline_ctor_params.push_back(KParamParentRect);
+			}
+
+		if (iLine.iNeedsIndex) // this condition has already been tested when setting iBaseLineVariation, but check again here for completeness
+			{
+			multiline_ctor_params.push_back(CdlTkUtil::IntToString(iLine.iIsMirroredHorizontally));
+			}
+
+			for (int i=0; i<KTextOutputOrderSize; i++)
+				{
+				// need to worry about parameter mirroring here. The problem is that 
+				// the macro needs to have a fixed parameter ordering, but the parameters
+				// might vary between variants, therefore the order of mirrored parameters 
+				// may vary, e.g. (l, t) becomes (t, r) etc. Solution is to swap l and r if the line is mirrored
+				// just for the macro definition (not for the ctor). 
+				string name = KTextOutputOrder[i];
+				string nameMirrored = KTextOutputOrderMirrored[i];
+
+				const TValues& defValues = iLine[iLine.iIsMirroredHorizontally ? nameMirrored : name];
+				if (defValues.iNeedsIndex) 
+					{
+					if (defValues.iName != "B") 
+						{
+						string param = CdlTkUtil::ToCpp(defValues.ParamName());
+						if (find(multiline_def_params.begin(), multiline_def_params.end(), param) == multiline_def_params.end())
+							{
+							multiline_def_params.push_back(param);
+							}
+// A variable parameter that is tied to the baseline is NOT suppressed in the Multiline
+// You have to supply the parameter in the macro as a zero
+						}
+					}
+
+				const TValues& ctorValues = iLine[name];
+				if (ctorValues.iNeedsIndex)
+					{
+					if (defValues.iName != "B") 
+						{
+						string param = CdlTkUtil::ToCpp(ctorValues.ParamName());
+						multiline_ctor_params.push_back(param);
+// A variable parameter that is tied to the baseline is NOT suppressed in the Multiline
+// You have to supply the parameter in the macro as a zero
+						}
+					else
+						{
+						multiline_ctor_params.push_back("0");
+						}
+					}
+				else
+					{
+					multiline_ctor_params.push_back("0");
+					}
+
+				} // end of for loop
+
+		// The final param for the multiline macro is user input for the layout utilities (pass-through data)
+		multiline_def_params.push_back(KParamNameNumberOfLinesShown);
+		multiline_ctor_params.push_back(KParamNameNumberOfLinesShown);
+
+		aLag << "#define AKN_LAYOUT_MULTILINE_TEXT_" << Name();
+		WriteParamList(aLag, multiline_def_params);
+		aLag << "\t" + KTypeMultiLineTextLayout;
+		WriteParamList(aLag, multiline_ctor_params);
+		aLag << endl;
+		} // end of if on baseline_variation
+	}
+
+
+void TTextLineCppWriter::WriteLineClassName(ostream& aCpp)
+	{
+	if (iLine.iNeedsIndex)
+		{
+		aCpp << "const SVarTextLine<" << ValCount()  << "> ";
+		}
+	else
+		{
+		aCpp << "const SFixedTextLine ";
+		}
+	}
+
+void TTextLineCppWriter::WriteVarCppData(ostream& aCpp)
+	{
+	aCpp << " { ";  // ! Do not write out the first 0
+
+	int offset = 0;
+	for (int i=0; i<KTextOutputOrderSize-1; i++) // last offset IS used because font id is written out
+		{
+		offset += iLine[KTextOutputOrder[i]].size();
+		if ( i != 0 )
+			aCpp << ", "; 
+		aCpp << offset;
+		}
+
+	aCpp << " }, { ";
+
+	WriteFixedCppData(aCpp);
+
+	aCpp << " }";
+	}
+
+void TTextLineCppWriter::WriteFixedCppData(ostream& aCpp)
+	{
+	for (int i=0; i<KTextOutputOrderSize; i++)
+		{
+		if ( i > 0 )
+			aCpp << ", ";
+		TValuesCppWriter writer(iLine[KTextOutputOrder[i]]);
+		writer.WriteCpp(aCpp);
+		}
+	}
+
+void TTextLineCppWriter::WriteMultiLineTextParamList(ostream& aLag, const vector<string>& aParams)
+	{
+	if (aParams.size() > 0)
+		{
+		aLag << "(";
+		for (vector<string>::const_iterator pParam = aParams.begin(); pParam != aParams.end(); ++pParam)
+			{
+			if (pParam != aParams.begin())
+				aLag << ", ";
+			aLag << *pParam;
+			}
+		aLag << ", " << KParamNameNumberOfLinesShown;
+		aLag << ")";
+		}
+	}
+
+
+// class TLayoutTableCppWriter
+
+void TLayoutTableCppWriter::WriteCppLineData(ostream& aCpp)
+	{
+	for (TLayoutTable::iterator it = iTable.begin(); it != iTable.end(); ++it)
+		{
+		TLayoutLineCppWriter* writer = CreateLayoutLineCppWriter(**it, iTable);
+		writer->WriteCpp(aCpp);
+		delete writer;
+		}
+	}
+
+void TLayoutTableCppWriter::WriteCppTableData(ostream& aCpp)
+	{
+	}
+
+void TLayoutTableCppWriter::WriteLag(ostream& aLag)
+	{
+	aLag << endl;
+	int count=0;
+	for (TLayoutTable::TLayoutSubTables::iterator it = iTable.iSubTables.begin(); it != iTable.iSubTables.end(); ++it)
+		{
+		WriteLagSubTable(**it, count++, aLag);
+		}
+	}
+
+
+void TLayoutTableCppWriter::WriteLagSubTable(const TLayoutTable::TLayoutSubTable& aSubTable, int aCount, ostream& aLag)
+	{
+	// normal version
+	string macro = "#define AKN_LAYOUT_TABLE_";
+	macro = macro + CdlTkUtil::ToCpp(iTable.Name());
+	if (aSubTable.size() != iTable.size())
+		{
+		macro = macro + "_SUB_TABLE_" + CdlTkUtil::IntToString(aCount);
+		aLag << "// Sub table for " << iTable.Name() << ". Valid line indices are ";
+		for (TLayoutTable::TLayoutSubTable::const_iterator pNum = aSubTable.begin(); pNum != aSubTable.end(); ++pNum)
+			{
+			if (pNum != aSubTable.begin())
+				aLag << ", ";
+			aLag << CdlTkUtil::IntToString(*pNum);
+			}
+		aLag << endl;
+		}
+
+	aLag << macro;
+
+	int lineSet = 0;
+	for (TLayoutTable::TLayoutSubTable::const_iterator pNum = aSubTable.begin(); pNum != aSubTable.end(); ++pNum)
+		{
+		if (*pNum < 32)
+			lineSet |= (1 << *pNum);
+		}
+
+	vector<string> def_params;
+	def_params.push_back(KParamLineIndex);
+	vector<string> ctor_params;
+	ctor_params.push_back(CdlTkUtil::IntToString(iTable.iFirstLineGlobalIndex));
+	ctor_params.push_back(KParamLineIndex);
+	ctor_params.push_back(CdlTkUtil::IntToHexString(lineSet));
+
+	TLayoutLineCppWriter* writer = CreateLayoutLineCppWriter(*iTable[aSubTable[0]], iTable);
+	writer->FillParamLists(def_params, ctor_params);
+	int paramSize = writer->WriteParamList(aLag, def_params);
+
+	// some maths to make bigger tabulation
+	int numTabs = 6-(((paramSize+macro.size())/4)%6);
+	for (int i=0; i<numTabs; i++)
+		aLag << "\t";
+
+	if (iTable.iType == TLayoutTable::EWindowTable)
+		aLag << KTypeWindowLineLayout;
+	else
+		aLag << KTypeTextLineLayout;
+	writer->WriteParamList(aLag, ctor_params);
+	aLag << endl;
+
+	delete writer;
+	}
+
+TLayoutLineCppWriter* TLayoutTableCppWriter::CreateLayoutLineCppWriter(TLayoutLine& aLine, TLayoutTable& aTable)
+	{
+	if (aTable.iType == TLayoutTable::EWindowTable)
+		return new TWindowLineCppWriter(aLine);
+	else
+		return new TTextLineCppWriter(aLine);
+	}
+
+
+// class TLayoutCppWriter
+
+void TLayoutCppWriter::WriteCppLineData(ostream& aCpp)
+	{
+	for (TLayout::iterator it = iLayout.begin(); it != iLayout.end(); ++it)
+		{
+		TLayoutTableCppWriter writer(**it);
+		writer.WriteCppLineData(aCpp);
+		}
+	}
+
+void TLayoutCppWriter::WriteCppTableData(ostream& aCpp)
+	{
+	}
+
+void TLayoutCppWriter::WriteLag(ostream& aLag)
+	{
+	aLag << endl << endl << "// Layout MACROs for indexed table access" << endl;
+	// write the macros
+	for (TLayout::iterator it = iLayout.begin(); it != iLayout.end(); ++it)
+		{
+		TLayoutTable& table = **it;
+		if (table.IsWorthATableIndex())
+			{
+			TLayoutTableCppWriter writer(table);
+			writer.WriteLag(aLag);
+			}
+		}
+
+	aLag << endl << "#endif " << endl;
+	}
+
+
+// class TLayoutLineTable
+
+void TLayoutLineTable::WriteCpp(ostream& aCpp)
+	{
+	aCpp << "const TAny* const KTheLineTable[] =" << endl << "\t{" << endl << "\t";
+	int index = 0;
+	for (iterator it = begin(); it != end(); ++it)
+		{
+		TLayoutLine& line = **it;
+		TLayoutTable& table = *line.iTable;
+		if (table.iFirstLineGlobalIndex == -1)
+			table.iFirstLineGlobalIndex = index;
+		TLayoutLineCppWriter* writer = TLayoutTableCppWriter::CreateLayoutLineCppWriter(line, table);
+		if (it != begin())
+			aCpp << "," << endl << "\t";
+		aCpp << "&" << writer->Name();
+		delete writer;
+		index++;
+		}
+	aCpp << endl << "\t};" << endl;
+	}
+
+void TLayoutLineTable::WriteLag(ostream& aLag)
+	{
+	string current_table_name = "";
+
+	for (iterator it = begin(); it != end(); ++it)
+		{
+		TLayoutLine& line = **it;
+
+		if ( current_table_name != line.iTable->Name() )
+			{
+			aLag << endl << "//" << " Layout MACROs for LAF Table : " << line.iTable->Name() << endl ;
+			current_table_name = line.iTable->Name();
+			}
+
+		TLayoutLineCppWriter* writer = TLayoutTableCppWriter::CreateLayoutLineCppWriter(line, *line.iTable);
+		writer->WriteMacro(aLag);
+		delete writer;
+		}
+	}
+
+
+// class TLayoutLineTable
+
+TCppWriter::TCppWriter(TLayout& aLayout, const std::string& aName)
+: TLayWriterBase(aLayout, aName)
+	{
+	}
+
+void TCppWriter::Write(const std::string& aLayName)
+	{
+	std::string lay = aLayName.substr(aLayName.find_last_of('\\')+1);
+	lay = lay.substr(0, lay.find_first_of('.'));
+
+	iShortName = iName.substr(iName.find_last_of('\\')+1);
+	iName = iName.substr(0, iName.find_first_of('.')) + lay;
+
+	BuildLayoutLineTable();
+	CCdlTkFileCleanup temp(iName+".lag");
+	Output(iName+".cpp", iName+".lag", lay);
+	CdlTkUtil::ExportFile(temp, KDirEpocSysHeader+iShortName+".lag");
+	}
+
+void TCppWriter::Output(const string& aCpp, const string& aLag, const string& aLayName)
+	{
+	cout << "writing cpp " << aCpp << endl;
+	ofstream cpp(aCpp.c_str());
+	WriteCppHeader(cpp);
+	TLayoutCppWriter writer(iLayout);
+	writer.WriteCppLineData(cpp);
+	iLineTable.WriteCpp(cpp);
+	writer.WriteCppTableData(cpp);
+	WriteCppFooter(cpp, aLayName);
+	cpp.close();
+
+	cout << "writing header " << aLag << endl;
+	ofstream lag(aLag.c_str());
+	WriteLagHeader(lag);
+	iLineTable.WriteLag(lag);
+	writer.WriteLag(lag);
+	lag.close();
+	}
+
+void TCppWriter::BuildLayoutLineTable()
+	{
+	int globalIndex = 0;
+	for (TLayout::const_iterator pTab = iLayout.begin(); pTab != iLayout.end(); ++pTab)
+		{
+		for (TLayoutTable::const_iterator pLine = (*pTab)->begin(); pLine != (*pTab)->end(); ++pLine)
+			{
+			(*pLine)->iGlobalIndex = globalIndex++;
+			iLineTable.push_back(*pLine);
+			}
+		}
+	}
+
+void TCppWriter::WriteCppHeader(ostream& aCpp)
+	{
+	aCpp << "/*" << endl;
+	aCpp << "* ============================================================================" << endl;
+	aCpp << "*  Name     : " << iShortName << ".cpp" << endl;
+	aCpp << "*  Part of  : Avkon" << endl;
+	aCpp << "*" << endl;
+	aCpp << "*  Description: This file is automatically generated layout data file." << endl;
+	aCpp << "*" << endl;
+	aCpp << "*  Version  :" << endl;
+	aCpp << "*" << endl;
+	aCpp << "*  Copyright © 2002-2004 Nokia Corporation." << endl;
+	aCpp << "*  This material, including documentation and any related" << endl;
+	aCpp << "*  computer programs, is protected by copyright controlled by" << endl;
+	aCpp << "*  Nokia Corporation. All rights are reserved. Copying,"<< endl;
+	aCpp << "*  including reproducing, storing,  adapting or translating, any" << endl;
+	aCpp << "*  or all of this material requires the prior written consent of" << endl;
+	aCpp << "*  Nokia Corporation. This material also contains confidential" << endl;
+	aCpp << "*  information which may not be disclosed to others without the" << endl;
+	aCpp << "*  prior written consent of Nokia Corporation." << endl;
+	aCpp << "* ============================================================================" << endl;
+	aCpp << "*/" << endl  << endl;
+	aCpp << "#include \"aknlayoutdatadef.h\"" << endl << endl;
+	}
+
+void TCppWriter::WriteCppFooter(ostream& aCpp, const string& aLayName)
+	{
+	aCpp << endl << "const TAny* GetData_" << aLayName << "(" << KTypeInt << " aLineId) { return KTheLineTable[aLineId]; }" << endl;
+	}
+
+void TCppWriter::WriteLagHeader(ostream& aLag)
+	{
+	aLag << "/*" << endl;
+	aLag << "* ============================================================================" << endl;
+	aLag << "*  Name     : " << iShortName << ".lag" << endl;
+	aLag << "*  Part of  : Avkon" << endl;
+	aLag << "*" << endl;
+	aLag << "*  Description: This file is automatically generated layout file." << endl;
+	aLag << "*" << endl;
+	aLag << "*  Version  :" << endl;
+	aLag << "*" << endl;
+	aLag << "*  Copyright © 2002-2004 Nokia Corporation." << endl;
+	aLag << "*  This material, including documentation and any related" << endl;
+	aLag << "*  computer programs, is protected by copyright controlled by" << endl;
+	aLag << "*  Nokia Corporation. All rights are reserved. Copying,"<< endl;
+	aLag << "*  including reproducing, storing,  adapting or translating, any" << endl;
+	aLag << "*  or all of this material requires the prior written consent of" << endl;
+	aLag << "*  Nokia Corporation. This material also contains confidential" << endl;
+	aLag << "*  information which may not be disclosed to others without the" << endl;
+	aLag << "* ============================================================================" << endl;
+	aLag << "*/" << endl  << endl;
+	aLag << "#if !defined(__" << iShortName << "_LAG__)" << endl;
+	aLag << "#define __" << iShortName << "_LAG__" << endl;
+	aLag << "#include <aknlayoutdef.h>" << endl << endl;
+	}
+
+// End of File