--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/aknlayoutcompiler/src/MLEqCompData2DHuiML.cpp Thu Dec 17 09:14:18 2009 +0200
@@ -0,0 +1,585 @@
+/*
+* Copyright (c) 2007 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:
+*
+*/
+
+
+// disable "identifier was truncated to '255' characters in the browser information" warning
+#pragma warning (disable:4786)
+
+#include "MLEqCompData2DHuiML.h"
+#include "MLEqCompDataParse.h"
+#include "LayoutCompilerErr.h"
+#include "FormulaTree.h"
+
+#include <cdlcompilertoolkit/cdltkprocess.h>
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+
+#include "CodeGenConsts.h"
+
+
+using namespace std;
+
+typedef LayoutProcessArgsErr<MLEqCompDataToDHuiML> MLEqCompDataToDHuiMLArgsErr;
+
+// constants
+
+const string KCompDataFileNameSuffix("compData");
+const string KAttributesFileNameSuffix("attributes");
+
+
+//
+// class TEqLayoutSaxWriter
+//
+
+
+class TEqLayoutSaxWriter
+ {
+public:
+ enum
+ {
+ KIndentSize=4
+ };
+public:
+ TEqLayoutSaxWriter(ofstream& aStream);
+ void StartDocument();
+ void EndDocument();
+ void OpenStartElement(const string& aLocalName);
+ void CloseStartElement();
+ void CloseAndEndStartElement();
+ void EndElement(const string& aLocalName);
+ void Attribute(const string& aLocalName, const string& aValue);
+ void Comment(const string& aComment);
+
+private:
+ void Indent();
+ void IncreaseIndentLevel();
+ void DecreaseIndentLevel();
+private:
+ ofstream& iStream;
+ int iIndentLevel;
+ };
+
+TEqLayoutSaxWriter::TEqLayoutSaxWriter(ofstream& aStream)
+ :
+ iStream(aStream),
+ iIndentLevel(0)
+ {
+
+ };
+
+void TEqLayoutSaxWriter::StartDocument()
+ {
+ Indent();
+ iStream << string("<xmluiml xmlns=\"http://www.series60.com/xml/xmluiml/1\">") << endl;
+ IncreaseIndentLevel();
+ }
+
+void TEqLayoutSaxWriter::EndDocument()
+ {
+ DecreaseIndentLevel();
+ Indent();
+ iStream << string("</xmluiml>") << endl;
+ }
+
+//void TEqLayoutSaxWriter::StartElement(const string& /*namespaceURI*/, const string& localName /*, const string& qName*/ /*, const AttributesT& atts*/)
+void TEqLayoutSaxWriter::OpenStartElement(const string& aLocalName)
+ {
+ Indent();
+ iStream << "<" << aLocalName;
+ IncreaseIndentLevel();
+ }
+
+void TEqLayoutSaxWriter::CloseStartElement()
+ {
+ iStream << ">" << endl;
+ }
+
+void TEqLayoutSaxWriter::CloseAndEndStartElement()
+ {
+ iStream << " />" << endl;
+ DecreaseIndentLevel();
+ }
+
+void TEqLayoutSaxWriter::EndElement(const string& aLocalName)
+ {
+ DecreaseIndentLevel();
+ Indent();
+ iStream << "</" << aLocalName << ">" << endl;
+ }
+
+void TEqLayoutSaxWriter::Attribute(const string& aLocalName, const string& aValue)
+ {
+ iStream << " " << aLocalName << "=\"" << aValue << "\"";
+ }
+
+void TEqLayoutSaxWriter::Comment(const string& aComment)
+ {
+ iStream << "<!-- " << aComment << " -->" << endl;
+ }
+
+void TEqLayoutSaxWriter::Indent()
+ {
+ stringstream ss;
+ int max = iIndentLevel * KIndentSize;
+ for(int count = 0; count < max; count++)
+ {
+ ss << " ";
+ }
+ iStream << ss.str();
+ }
+
+void TEqLayoutSaxWriter::IncreaseIndentLevel()
+ {
+ if(iIndentLevel > 1000)
+ throw GeneralErr("TEqLayoutSaxWriter::DecreaseIndentLevel - nesting inconsistency");
+ iIndentLevel++;
+ }
+
+void TEqLayoutSaxWriter::DecreaseIndentLevel()
+ {
+ if(iIndentLevel == 0)
+ throw GeneralErr("TEqLayoutSaxWriter::DecreaseIndentLevel - nesting inconsistency");
+ iIndentLevel--;
+ }
+
+
+
+//
+// MLEqCompDataToDHuiML
+//
+
+int MLEqCompDataToDHuiML::Process(const vector<string>& args)
+ {
+ int numExpectedArgs = 5;
+ int numArgs = args.size();
+ if(numArgs < numExpectedArgs)
+ throw MLEqCompDataToDHuiMLArgsErr();
+
+ int arg = 2;
+ string listName = args[arg++];
+ string compDataName = args[arg++];
+ string parChildName = args[arg++];
+ string dhuimlName = args[arg++];
+
+ auto_ptr<TMLEqCompDataParseLayout> layoutParse = TMLEqCompDataParseLayout::Parse(listName, compDataName, parChildName);
+ auto_ptr<TMLEqCompData> layout(layoutParse.get());
+ layoutParse.release();
+
+ TMLEqCompData* theLayout = layout.get();
+ theLayout->Compile();
+
+ cout << "writing dhuiml file " << dhuimlName << endl;
+ ofstream dhuiml(dhuimlName.c_str());
+
+ int KIndent = 4;
+ TEqLayoutSaxWriter saxWriter(dhuiml);
+ saxWriter.StartDocument();
+
+ stringstream comment1;
+ comment1 << "Generated from list: " << listName;
+ saxWriter.Comment(comment1.str());
+
+ stringstream comment2;
+ comment2 << "Generated from component data: " << compDataName;
+ saxWriter.Comment(comment2.str());
+
+ stringstream comment3;
+ comment3 << "Generated from parent child data: " << parChildName;
+ saxWriter.Comment(comment3.str());
+
+ LayoutTablesToDeclarative(saxWriter, *theLayout);
+
+ saxWriter.EndDocument();
+
+ return 0;
+ }
+
+void MLEqCompDataToDHuiML::ShowHelp(ostream& stream)
+ {
+ stream << "MLEqCompData2DHuiML <MLEqCompListName> <MLEqCompDataName> <MLEqParChildName> <DHuiMLName>" << endl;
+ stream << " e.g. from \\S60\\AknLayout2\\group run " << endl;
+ stream << " aknlayoutcompiler MLEqCompData2DHuiML " << endl;
+ stream << " ..\\..\\xml_master\\xml\\m_p_30\\m_p_30_list.xml " << endl;
+ stream << " ..\\..\\xml_master\\xml\\m_p_30\\m_p_30\\0.161093285736413\\eur_compData.xml " << endl;
+ stream << " ..\\..\\xml_master\\xml\\m_p_30\\m_p_30\\0.161093285736413\\eur_parChildRelation.xml " << endl;
+ stream << " ..\\generated_declarative\\lct_avkon.dhuiml" << endl;
+ }
+
+void MLEqCompDataToDHuiML::LayoutTablesToDeclarative(TEqLayoutSaxWriter& aSaxWriter, const TMLEqCompData& aLayout)
+ {
+ // first the tables are output
+ for (TMLEqCompData::const_iterator pTab = aLayout.begin(); pTab != aLayout.end(); ++pTab)
+ {
+ AddTableToDeclarative(aSaxWriter, **pTab);
+ }
+ }
+
+void MLEqCompDataToDHuiML::LayoutComponentsToDeclarative(TEqLayoutSaxWriter& aSaxWriter, const TMLEqCompData& aLayout)
+ {
+ // then the individual components are output
+ for (TMLEqCompData::TMLEqCompDataComponents::const_iterator pLine = aLayout.iComponents.begin(); pLine != aLayout.iComponents.end(); ++pLine)
+ {
+ // @todo this may be needed if the components are to be written out separately from the tables
+ }
+ }
+
+
+const string KDHuiMLLayoutmanager("layoutmanager");
+const string KDHuiMLLayoutmanagerId("id");
+const string KDHuiMLLayoutmanagerName("name");
+const string KDHuiMLOptionSet("optionset");
+const string KDHuiMLOptionSetId("id");
+const string KDHuiMLOptionSetOrientationPortrait("portrait");
+const string KDHuiMLOptionSetOrientationLandscape("landscape");
+const string KDHuiMLOptionSetOrientationTrue("true");
+const string KDHuiMLOptionSetOrientationFalse("false");
+
+void MLEqCompDataToDHuiML::AddTableToDeclarative(TEqLayoutSaxWriter& aSaxWriter, TMLEqCompDataTable& aTable)
+ {
+ if(aTable.size() == 0)
+ return;
+
+// <layoutmanager id="1233" name="listscroll_app_pane">
+// <optionset id="0" portrait="true" landscape="false">
+// <lctcomponent id="1234" name="grid_app_pane">
+
+ aSaxWriter.OpenStartElement(KDHuiMLLayoutmanager);
+ aSaxWriter.Attribute(KDHuiMLLayoutmanagerId, CdlTkUtil::IntToString(aTable.iId));
+ aSaxWriter.Attribute(KDHuiMLLayoutmanagerName, aTable.iName);
+ aSaxWriter.CloseStartElement();
+
+ // iterate through option sets
+ for(TMLEqCompDataTable::iterator pOptionSet = aTable.begin(); pOptionSet != aTable.end(); ++pOptionSet)
+ {
+ int optionSetId = pOptionSet->first;
+ TMLEqCompDataTableOptionSet& optionSet = pOptionSet->second;
+ aSaxWriter.OpenStartElement(KDHuiMLOptionSet);
+ aSaxWriter.Attribute(KDHuiMLOptionSetId, CdlTkUtil::IntToString(optionSetId));
+
+ string isPortrait = (optionSet.iOrientation & EMLEqCompDataOptionSetOrientationPortrait) ? KDHuiMLOptionSetOrientationTrue : KDHuiMLOptionSetOrientationFalse;
+ aSaxWriter.Attribute(KDHuiMLOptionSetOrientationPortrait, isPortrait);
+ string isLandscape = (optionSet.iOrientation & EMLEqCompDataOptionSetOrientationLandscape) ? KDHuiMLOptionSetOrientationTrue : KDHuiMLOptionSetOrientationFalse;
+ aSaxWriter.Attribute(KDHuiMLOptionSetOrientationLandscape, isLandscape);
+
+ aSaxWriter.CloseStartElement();
+
+ for(TMLEqCompDataTableOptionSet::iterator pLine = optionSet.begin(); pLine != optionSet.end(); ++pLine)
+ {
+ AddLineToDeclarative(aSaxWriter, **pLine, optionSetId);
+ }
+ aSaxWriter.EndElement(KDHuiMLOptionSet);
+ }
+
+ aSaxWriter.EndElement(KDHuiMLLayoutmanager);
+ }
+
+
+const string KDHuiMLLCTComponent("lctcomponent");
+const string KDHuiMLLCTComponentId("id");
+const string KDHuiMLLCTComponentName("name");
+const string KDHuiMLAlfLayout("alflayout");
+const string KDHuiMLAlfLayoutType("type");
+const string KDHuiMLAlfLayoutTypeAnchor("anchor");
+
+void MLEqCompDataToDHuiML::AddLineToDeclarative(TEqLayoutSaxWriter& aSaxWriter, TMLEqCompDataLine& aLine, int aOptionSetId)
+ {
+ // beginning of component
+
+// <lctcomponent id="1234" name="grid_app_pane">
+// <alflayout type="anchor">
+
+ aSaxWriter.OpenStartElement(KDHuiMLLCTComponent);
+ aSaxWriter.Attribute(KDHuiMLLCTComponentId, CdlTkUtil::IntToString(aLine.iId));
+ aSaxWriter.Attribute(KDHuiMLLCTComponentName, aLine.iName);
+ aSaxWriter.CloseStartElement();
+
+ aSaxWriter.OpenStartElement(KDHuiMLAlfLayout);
+ aSaxWriter.Attribute(KDHuiMLAlfLayoutType, KDHuiMLAlfLayoutTypeAnchor);
+ aSaxWriter.CloseStartElement();
+
+ const string* outputOrder = KEqCompDataPaneOutputOrder;
+ const int outputSize = KEqCompDataPaneOutputOrderSize;
+ vector<string> cellOrder(outputOrder, outputOrder + outputSize);
+
+ for (vector<string>::iterator pCell = cellOrder.begin(); pCell != cellOrder.end(); ++pCell)
+ {
+ string cellName = *pCell;
+ AddCellToDeclarative(aSaxWriter, aLine[cellName], cellName, aOptionSetId);
+ }
+
+ aSaxWriter.EndElement(KDHuiMLAlfLayout);
+ aSaxWriter.EndElement(KDHuiMLLCTComponent);
+ }
+
+const string KDHuiMLAnchor("anchor");
+const string KDHuiMLAnchorOrdinal("ordinal");
+const string KDHuiMLAnchorType("type");
+const string KDHuiMLAnchorTypePrefix("EAlfAnchorType"); // not currently used, to save disk space
+const string KDHuiMLAnchorAttachmentOrigin("attachmentOrigin");
+const string KDHuiMLAnchorAttachmentOriginPrefix("EAlfAnchorAttachmentOrigin"); // not currently used, to save disk space
+const string KDHuiMLAnchorAttachmentOrdinal("attachmentOrdinal");
+const string KDHuiMLAnchorAttachmentOrdinalAttachToParent("P");
+const string KDHuiMLAnchorOffset("offset");
+const string KDHuiMLAnchorOffsetMagnitude("magnitude");
+const string KDHuiMLAnchorOffsetUnit("unit");
+const string KDHuiMLAnchorOffsetUnitPixel("S60");
+
+void MLEqCompDataToDHuiML::AddCellToDeclarative(TEqLayoutSaxWriter& aSaxWriter, TMLEqCompDataValues& aValues, const string& aCellName, int aOptionSetId)
+ {
+// <anchor
+// ordinal="0" // don't need this, as declarative can calculate drawing order at runtime
+// type="EAlfAnchorTypeLeft"
+// attachmentOrigin="EAlfAnchorAttachmentOriginLeft"
+// attachmentOrdinal="EAlfAnchorAttachToParent">
+// <offset
+// magnitude="20"
+// unit="EAlfUnitPixel"
+// zoomId = "233" />
+// <formula formulaStr=""> // @todo this is temporary whilst equation evaluation is developed
+// ...
+// </formula>
+// </anchor>
+
+ bool validCell(false);
+ TMLEqCompDataFormula* formula = NULL;
+ TMLEqCompDataValuesOptionSet& optionSet = aValues.iOptionSets[aOptionSetId];
+ // always assume it's the first and only forumla
+ if(optionSet.size() > 0)
+ {
+ formula = &(optionSet[0]);
+ if(!formula->iFormulaString.empty())
+ {
+ validCell = true;
+ }
+ }
+
+ if(!validCell)
+ return;
+
+ aSaxWriter.OpenStartElement(KDHuiMLAnchor);
+
+// aSaxWriter.Attribute(KDHuiMLAnchorOrdinal, 0); // don't need this, as declarative can calculate drawing order at runtime
+
+ string anchorType = aCellName;
+ ConvertPositionValueStr(anchorType);
+ aSaxWriter.Attribute(KDHuiMLAnchorType, anchorType);
+
+ // @todo for now, always attach to the same side, but need to calculate this for e.g. orthogonal anchors
+ aSaxWriter.Attribute(KDHuiMLAnchorAttachmentOrigin, anchorType);
+
+ aSaxWriter.Attribute(KDHuiMLAnchorAttachmentOrdinal, KDHuiMLAnchorAttachmentOrdinalAttachToParent);
+
+ aSaxWriter.CloseStartElement();
+
+ {
+ aSaxWriter.OpenStartElement(KDHuiMLAnchorOffset);
+ aSaxWriter.Attribute(KDHuiMLAnchorOffsetMagnitude, "0"); // @todo, replace with value in units!
+ aSaxWriter.Attribute(KDHuiMLAnchorOffsetUnit, KDHuiMLAnchorOffsetUnitPixel); // @todo, replace with s60 units when supported
+ aSaxWriter.CloseAndEndStartElement();
+ }
+
+ AddFormulaToDeclarative(aSaxWriter, *formula);
+
+ aSaxWriter.EndElement(KDHuiMLAnchor);
+ }
+
+
+//
+// this is all temporary, to illustrate equation parsing
+//
+
+
+const string KDHuiMLAnchorFormula("formula");
+const string KDHuiMLAnchorFormulaString("formulastr");
+const string KDHuiMLAnchorFormulaNode("node");
+const string KDHuiMLAnchorFormulaNodeType("type");
+const string KDHuiMLAnchorFormulaNodeValue("value");
+
+
+void Print(TEqLayoutSaxWriter& aSaxWriter, const FormulaTreeNode& aNode)
+ {
+ aSaxWriter.OpenStartElement(KDHuiMLAnchorFormulaNode);
+ stringstream ss;
+
+ switch (aNode.Type())
+ {
+ case FormulaTreeNode::EReal: // Double() = the number
+ ss << aNode.Real();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "real");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EInt: // Int() = the number
+ ss << aNode.Int();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "int");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::ECell: // Char() = cell name
+ ss << aNode.Char();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "cell");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EParent: // nothing special
+ ss << aNode.Char();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "parent");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EParentCell: // Char() = parent cell name
+ ss << aNode.Char();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "parent_cell");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::ETableCell: // Double() = target table
+ ss << aNode.Real();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "table_cell");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EComponent: // Double() = component id, [0] = cell name
+ ss << aNode.Real();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "component");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ break;
+ case FormulaTreeNode::EAbsolute: // Text() = whole thing, [0], [1] = real components, [2] = cell name
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "absolute_cell_ref");
+// aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ Print(aSaxWriter, aNode[1]);
+ Print(aSaxWriter, aNode[2]);
+ break;
+ case FormulaTreeNode::EUnits: // Double() = units
+ ss << aNode.Real();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "units");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EConstant: // Double() = constant
+ ss << aNode.Real();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "constant");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EAttribute: // Int() = attribute
+ ss << aNode.Int();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "attribute");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ break;
+ case FormulaTreeNode::EMystery: // Text() = whole thing, [0], [1] = int components
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "mystery");
+// aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ Print(aSaxWriter, aNode[1]);
+ break;
+ case FormulaTreeNode::EFunction: // Text() = function name, [0] = parameter
+ ss << aNode.Text();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "function");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ break;
+ case FormulaTreeNode::EArithmetic: // Char() = arithmetic operator, [0], [1] = sub expressions
+ ss << aNode.Char();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "arithmetic");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ Print(aSaxWriter, aNode[1]);
+ break;
+ case FormulaTreeNode::ECondition: // Text() = comparison operator, [0], [1] = sub expressions
+ ss << aNode.Text();
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "condition");
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ Print(aSaxWriter, aNode[1]);
+ break;
+ case FormulaTreeNode::EConditional: // no content, [0] = condition, [1] = then expression, [2] = else expression
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeType, "if_then_else");
+// aSaxWriter.Attribute(KDHuiMLAnchorFormulaNodeValue, ss.str());
+ aSaxWriter.CloseStartElement();
+ Print(aSaxWriter, aNode[0]);
+ Print(aSaxWriter, aNode[1]);
+ Print(aSaxWriter, aNode[2]);
+ break;
+ }
+ aSaxWriter.EndElement(KDHuiMLAnchorFormulaNode);
+ }
+
+
+void MLEqCompDataToDHuiML::AddFormulaToDeclarative(TEqLayoutSaxWriter& aSaxWriter, const TMLEqCompDataFormula& aFormula)
+ {
+// <formula formulaStr=""> // @todo this is temporary whilst equation evaluation is developed
+// <node type="123" value="456"/>
+// </formula>
+ aSaxWriter.OpenStartElement(KDHuiMLAnchorFormula);
+ aSaxWriter.Attribute(KDHuiMLAnchorFormulaString, aFormula.iFormulaString); // @todo, replace with expanded formula xml
+ aSaxWriter.CloseStartElement();
+
+ if(aFormula.iFormulaTree)
+ {
+ Print(aSaxWriter, *(aFormula.iFormulaTree));
+ }
+
+ aSaxWriter.EndElement(KDHuiMLAnchorFormula);
+ }
+
+extern const string KEqCompDataKeywordParamLeft;
+extern const string KEqCompDataKeywordParamTop;
+extern const string KEqCompDataKeywordParamRight;
+extern const string KEqCompDataKeywordParamBottom;
+extern const string KEqCompDataKeywordParamWidth;
+extern const string KEqCompDataKeywordParamHeight;
+
+const string KDHuiMLAnchorLeft("left");
+const string KDHuiMLAnchorTop("top");
+const string KDHuiMLAnchorRight("right");
+const string KDHuiMLAnchorBottom("bottom");
+const string KDHuiMLAnchorWidth("width");
+const string KDHuiMLAnchorHeight("height");
+
+void MLEqCompDataToDHuiML::ConvertPositionValueStr(std::string& aValueStr)
+ {
+ if(aValueStr == KEqCompDataKeywordParamLeft)
+ aValueStr = KDHuiMLAnchorLeft;
+ else if(aValueStr == KEqCompDataKeywordParamTop)
+ aValueStr = KDHuiMLAnchorTop;
+ else if(aValueStr == KEqCompDataKeywordParamRight)
+ aValueStr = KDHuiMLAnchorRight;
+ else if(aValueStr == KEqCompDataKeywordParamBottom)
+ aValueStr = KDHuiMLAnchorBottom;
+ else if(aValueStr == KEqCompDataKeywordParamWidth)
+ aValueStr = KDHuiMLAnchorWidth;
+ else if(aValueStr == KEqCompDataKeywordParamHeight)
+ aValueStr = KDHuiMLAnchorHeight;
+ else
+ aValueStr = KDHuiMLAnchorLeft;
+ }
+
+
+// end of file