--- a/src/hbutils/document/hbdocumentloadersyntax_p.cpp Mon Apr 19 14:02:13 2010 +0300
+++ b/src/hbutils/document/hbdocumentloadersyntax_p.cpp Mon May 03 12:48:33 2010 +0300
@@ -28,30 +28,75 @@
#include "hbdocumentloader_p.h"
#include "hbdocumentloader.h"
-#include <hbicon.h>
#include <hbfontspec.h>
-#include <QDebug>
+
#include <QMetaEnum>
+#include <QTranslator>
+#include <QDataStream>
-#include <QTranslator>
-#include <hbmainwindow.h>
+#include <QDebug>
// Document loader version number
#define VERSION_MAJOR 1
-#define VERSION_MINOR 0
+#define VERSION_MINOR 1
#define MIN_SUPPORTED_VERSION_MAJOR 0
#define MIN_SUPPORTED_VERSION_MINOR 1
+
+//#define LINE_DEBUGGING
+
+#ifdef LINE_DEBUGGING
+#include <QTime>
+static QTime lineDebugTime;
+
+#ifdef Q_OS_SYMBIAN
+#include <e32debug.h>
+#endif
+
+void doDebugPrint(const char* text)
+{
+#ifdef Q_OS_SYMBIAN
+ RDebug::Printf(text);
+#else
+ qDebug() << text;
+#endif
+}
+
+// Takes standard c-format.
+void debugPrint(const char* cformat, ...)
+{
+ va_list ap;
+ va_start(ap, cformat);
+ QString str = QString().vsprintf(cformat, ap);
+ va_end(ap);
+ doDebugPrint(str.toAscii().constData());
+}
+
+#endif // LINE_DEBUGGING
+
+const char *ZValueProperty = "z";
+
+class AccessToMetadata : public QObject
+ {
+ public:
+ int getEnumValue( const char *enumeration, const char *str )
+ {
+ QMetaObject metaobject = staticQtMetaObject;
+ QMetaEnum e = metaobject.enumerator( metaobject.indexOfEnumerator( enumeration ) );
+ return e.keysToValue( str );
+ }
+ };
+
/*
\class HbDocumentLoaderSyntax
\internal
\proto
*/
-HbDocumentLoaderSyntax::HbDocumentLoaderSyntax( HbDocumentLoaderActions *actions, const HbMainWindow *window )
-: HbXmlLoaderAbstractSyntax( actions ), mRealActions( actions ), mMainWindow(window)
+HbDocumentLoaderSyntax::HbDocumentLoaderSyntax( HbXmlLoaderAbstractActions *actions )
+: HbXmlLoaderBaseSyntax( actions )
{
}
@@ -59,10 +104,30 @@
{
}
+bool HbDocumentLoaderSyntax::scanForSections( QIODevice *device, QList<QString> §ionsList )
+{
+#ifdef LINE_DEBUGGING
+ lineDebugTime.restart();
+ debugPrint("MYTRACE: DocML scanForSections, start");
+#endif
+ bool ret = HbXmlLoaderBaseSyntax::scanForSections( device, sectionsList );
+#ifdef LINE_DEBUGGING
+ debugPrint("MYTRACE: DocML scanForSections, end: %d", lineDebugTime.elapsed());
+#endif
+ return ret;
+}
+
bool HbDocumentLoaderSyntax::load( QIODevice *device, const QString §ion )
{
- mCurrentProfile = HbDeviceProfile::profile(mMainWindow);
- return HbXmlLoaderAbstractSyntax::loadDevice( device, section );
+#ifdef LINE_DEBUGGING
+ lineDebugTime.restart();
+ debugPrint("MYTRACE: DocML load, start");
+#endif
+ bool ret = HbXmlLoaderBaseSyntax::loadDevice( device, section );
+#ifdef LINE_DEBUGGING
+ debugPrint("MYTRACE: DocML load, end: %d", lineDebugTime.elapsed());
+#endif
+ return ret;
}
bool HbDocumentLoaderSyntax::readLayoutStartItem()
@@ -76,17 +141,20 @@
const QString src = attribute( AL_SRC_NAME );
const QString dst = attribute( AL_DST_NAME );
- const QString srcEdge = attribute( AL_SRC_EDGE );
- const QString dstEdge = attribute( AL_DST_EDGE );
+ const QString srcEdgeStr = attribute( AL_SRC_EDGE );
+ const QString dstEdgeStr = attribute( AL_DST_EDGE );
const QString spacing = attribute( AL_SPACING );
const QString spacer = attribute( AL_SPACER );
- qreal spacingVal = 0;
+ HbXmlLengthValue spacingVal;
result = true;
if( !spacing.isEmpty() ) {
- result = toPixels( spacing, spacingVal );
+ result = toLengthValue( spacing, spacingVal );
}
- if (result) {
- result = mRealActions->addAnchorLayoutEdge( src, srcEdge, dst, dstEdge, spacingVal, spacer );
+ Hb::Edge srcEdge, dstEdge;
+ result &= getAnchorEdge( srcEdgeStr, srcEdge );
+ result &= getAnchorEdge( dstEdgeStr, dstEdge );
+ if ( result ) {
+ result = mActions->addAnchorLayoutEdge( src, srcEdge, dst, dstEdge, spacingVal, spacer );
}
}
break;
@@ -97,28 +165,148 @@
if( mReader.name() == lexemValue( GL_GRIDCELL ) ) {
const QString src = attribute( GL_ITEMNAME );
-
const QString row = attribute( GL_ROW );
const QString column = attribute( GL_COLUMN );
const QString rowspan = attribute( GL_ROWSPAN );
const QString columnspan = attribute( GL_COLUMNSPAN );
const QString alignment = attribute( TYPE_ALIGNMENT );
- result = mRealActions->addGridLayoutCell( src, row, column, rowspan, columnspan, alignment );
+
+ int rownum = row.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO ROW SPECIFIED" ) );
+ break;
+ }
+
+ int columnnum = column.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO COLUMN SPECIFIED" ) );
+ break;
+ }
+
+ int rowspannum;
+ int *rowspan_p = 0;
+ if (!rowspan.isEmpty()) {
+ rowspannum = rowspan.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: INVALID ROWSPAN" ) );
+ break;
+ } else {
+ rowspan_p = &rowspannum;
+ }
+ }
+
+ int columnspannum;
+ int *columnspan_p = 0;
+ if (!columnspan.isEmpty()) {
+ columnspannum = columnspan.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: INVALID ROWSPAN" ) );
+ break;
+ } else {
+ columnspan_p = &columnspannum;
+ }
+ }
+
+ Qt::Alignment align;
+ Qt::Alignment *align_p = 0;
+ if (!alignment.isEmpty()) {
+ AccessToMetadata myAccess;
+ int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );
+ if (value == -1) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO SUCH ALIGNMENT " ) + alignment );
+ result = false;
+ break;
+ } else {
+ align = (Qt::Alignment)value;
+ align_p = &align;
+ }
+ }
+ result = mActions->addGridLayoutCell( src, rownum, columnnum, rowspan_p, columnspan_p, align_p );
} else if( mReader.name() == lexemValue( GL_GRIDROW ) ) {
const QString row = attribute( GL_ROW );
const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );
const QString alignment = attribute( TYPE_ALIGNMENT );
- result = mRealActions->setGridLayoutRowProperties( row, stretchfactor, alignment );
+
+ const int rownum = row.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO ROW NUMBER SPECIFIED FOR STRETCH FACTOR" ) );
+ break;
+ }
+
+ int stretchnum;
+ int *stretch_p = 0;
+ if( !stretchfactor.isEmpty() ) {
+ stretchnum = stretchfactor.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: UNABLE TO PARSE ROW STRETCH FACTOR VALUE" ) );
+ break;
+ } else {
+ stretch_p = &stretchnum;
+ }
+ }
+
+ Qt::Alignment align;
+ Qt::Alignment *align_p = 0;
+ if( !alignment.isEmpty() ) {
+ AccessToMetadata myAccess;
+
+ int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );
+ if( value == -1 ) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO SUCH ROW ALIGNMENT " ) + alignment );
+ result = false;
+ break;
+ } else {
+ align = (Qt::Alignment)value;
+ align_p = &align;
+ }
+ }
+
+ result = mActions->setGridLayoutRowProperties( rownum, stretch_p, align_p );
if (result) {
- result = processRowHeights( row );
+ result = processRowHeights( rownum );
}
} else if( mReader.name() == lexemValue( GL_GRIDCOLUMN ) ) {
const QString column = attribute( GL_COLUMN );
const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );
const QString alignment = attribute( TYPE_ALIGNMENT );
- result = mRealActions->setGridLayoutColumnProperties( column, stretchfactor, alignment );
+
+ const int columnnum = column.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO COLUMN NUMBER SPECIFIED FOR STRETCH FACTOR" ) );
+ break;
+ }
+
+ int stretchnum;
+ int *stretch_p = 0;
+ if (!stretchfactor.isEmpty()) {
+ stretchnum = stretchfactor.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: UNABLE TO PARSE COLUMN STRETCH FACTOR VALUE" ) );
+ break;
+ } else {
+ stretch_p = &stretchnum;
+ }
+ }
+
+ Qt::Alignment align;
+ Qt::Alignment *align_p = 0;
+ if (!alignment.isEmpty()) {
+ AccessToMetadata myAccess;
+
+ int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );
+ if (value == -1) {
+ HB_DOCUMENTLOADER_PRINT( QString( "GRIDLAYOUT: NO SUCH COLUMN ALIGNMENT " ) + alignment );
+ result = false;
+ break;
+ } else {
+ align = (Qt::Alignment)value;
+ align_p = &align;
+ }
+ }
+
+ result = mActions->setGridLayoutColumnProperties( columnnum, stretch_p, align_p );
if (result) {
- result = processColumnWidths( column );
+ result = processColumnWidths( columnnum );
}
} else if( mReader.name() == lexemValue( TYPE_CONTENTSMARGINS ) ) {
result = processContentsMargins();
@@ -130,26 +318,88 @@
HB_DOCUMENTLOADER_PRINT( "GENERAL LAYOUT START ITEM: LINEAR ITEM" );
if( mReader.name() == lexemValue( LL_LINEARITEM ) ) {
result = true;
+ const QString itemname = attribute( LL_ITEMNAME );
const QString index = attribute( LL_INDEX );
- const QString itemname = attribute( LL_ITEMNAME );
- const QString spacing = attribute( LL_SPACING );
const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );
const QString alignment = attribute( TYPE_ALIGNMENT );
-
- qreal spacingValue(0);
- qreal *spacingPtr(0);
- if( !spacing.isEmpty() ) {
- result = toPixels( spacing, spacingValue );
- spacingPtr = &spacingValue;
+ const QString spacing = attribute( LL_SPACING );
+
+ int indexnum;
+ int *index_p = 0;
+ if (!index.isEmpty()) {
+ indexnum = index.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE ITEM INDEX" ) );
+ break;
+ } else {
+ index_p = &indexnum;
+ }
+ }
+
+ int stretchnum;
+ int *stretch_p = 0;
+ if (!stretchfactor.isEmpty()) {
+ stretchnum = stretchfactor.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE STRETCH VALUE" ) );
+ break;
+ } else {
+ stretch_p = &stretchnum;
+ }
+ }
+
+ Qt::Alignment align;
+ Qt::Alignment *align_p = 0;
+ if (!alignment.isEmpty()) {
+ AccessToMetadata myAccess;
+
+ int value = myAccess.getEnumValue( "Alignment", alignment.toLatin1().data() );
+ if (value == -1) {
+ HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: NO SUCH ITEM ALIGNMENT " ) + alignment );
+ result = false;
+ break;
+ } else {
+ align = (Qt::Alignment)value;
+ align_p = &align;
+ }
+ }
+
+ HbXmlLengthValue spacingValue;
+ if (!spacing.isEmpty()) {
+ result = toLengthValue( spacing, spacingValue );
}
if (result) {
- result = mRealActions->addLinearLayoutItem( itemname, index, stretchfactor, alignment, spacingPtr );
+ result = mActions->addLinearLayoutItem( itemname, index_p, stretch_p, align_p, spacingValue );
}
} else if( mReader.name() == lexemValue( LL_STRETCH ) ) {
const QString index = attribute( LL_INDEX );
const QString stretchfactor = attribute( ATTR_STRETCHFACTOR );
- result = mRealActions->addLinearLayoutStretch( index, stretchfactor );
+ int indexnum;
+ int *index_p = 0;
+ if (!index.isEmpty()) {
+ indexnum = index.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE STRETCH INDEX" ) );
+ break;
+ } else {
+ index_p = &indexnum;
+ }
+ }
+
+ int stretchnum;
+ int *stretch_p = 0;
+ if (!stretchfactor.isEmpty()) {
+ stretchnum = stretchfactor.toInt( &result );
+ if (!result) {
+ HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: UNABLE TO PARSE STRETCH VALUE" ) );
+ break;
+ } else {
+ stretch_p = &stretchnum;
+ }
+ }
+
+ result = mActions->addLinearLayoutStretch( index_p, stretch_p );
} else if( mReader.name() == lexemValue( TYPE_CONTENTSMARGINS ) ) {
result = processContentsMargins();
}
@@ -163,7 +413,18 @@
const QString index = attribute( SL_INDEX );
const QString itemname = attribute( SL_ITEMNAME );
- result = mRealActions->addStackedLayoutItem( itemname, index );
+ int indexnum;
+ int *index_p = 0;
+ if( !index.isEmpty() ) {
+ indexnum = index.toInt( &result );
+ if( !result ) {
+ HB_DOCUMENTLOADER_PRINT( QString( "STACKEDLAYOUT: UNABLE TO PARSE ITEM INDEX" ) );
+ break;
+ } else {
+ index_p = &indexnum;
+ }
+ }
+ result = mActions->addStackedLayoutItem( itemname, index_p );
}
break;
@@ -178,6 +439,9 @@
qWarning() << "Internal error, wrong layout type, line " << mReader.lineNumber();
}
}
+#ifdef LINE_DEBUGGING
+ debugPrint("MYTRACE: --- after line %d, time: %d", (int)mReader.lineNumber(), lineDebugTime.elapsed());
+#endif
return result;
}
@@ -189,22 +453,22 @@
const QString bottomS = attribute( ATTR_BOTTOM );
bool result = true;
- qreal left = 0, top = 0, right = 0, bottom = 0;
+ HbXmlLengthValue left, top, right, bottom;
if ( !leftS.isEmpty() ) {
- result = toPixels(leftS, left);
+ result = toLengthValue(leftS, left);
}
if ( result && !topS.isEmpty() ) {
- result = toPixels(topS, top);
+ result = toLengthValue(topS, top);
}
if ( result && !rightS.isEmpty() ) {
- result = toPixels(rightS, right);
+ result = toLengthValue(rightS, right);
}
if ( result && !bottomS.isEmpty() ) {
- result = toPixels(bottomS, bottom);
+ result = toLengthValue(bottomS, bottom);
}
if ( result ) {
- result = mRealActions->setLayoutContentsMargins( left, top, right, bottom );
+ result = mActions->setLayoutContentsMargins( left, top, right, bottom );
}
if (!result) {
@@ -214,111 +478,96 @@
return result;
}
-bool HbDocumentLoaderSyntax::processRowHeights( const QString &row )
+bool HbDocumentLoaderSyntax::processRowHeights( int row )
{
const QString minHeightS = attribute( GL_MINHEIGHT );
const QString maxHeightS = attribute( GL_MAXHEIGHT );
const QString prefHeightS = attribute( GL_PREFHEIGHT );
const QString fixedHeightS = attribute( GL_FIXEDHEIGHT );
const QString rowSpacingS = attribute( GL_SPACING );
- qreal minHeight = -1;
- qreal maxHeight = -1;
- qreal prefHeight = -1;
- qreal fixedHeight = -1;
- qreal rowSpacing = -1;
+ HbXmlLengthValue minHeight, maxHeight, prefHeight, fixedHeight, rowSpacing;
bool result = true;
- int propertyAvailable = 0;
if ( !minHeightS.isEmpty() ) {
- result = toPixels(minHeightS, minHeight);
- propertyAvailable |= HbDocumentLoaderActions::propertyMin;
+ result = toLengthValue(minHeightS, minHeight);
}
if ( result && !maxHeightS.isEmpty() ) {
- result = toPixels(maxHeightS, maxHeight);
- propertyAvailable |= HbDocumentLoaderActions::propertyMax;
+ result = toLengthValue(maxHeightS, maxHeight);
}
if ( result && !prefHeightS.isEmpty() ) {
- result = toPixels(prefHeightS, prefHeight);
- propertyAvailable |= HbDocumentLoaderActions::propertyPref;
+ result = toLengthValue(prefHeightS, prefHeight);
}
if ( result && !fixedHeightS.isEmpty() ) {
- result = toPixels(fixedHeightS, fixedHeight);
- propertyAvailable |= HbDocumentLoaderActions::propertyFixed;
+ result = toLengthValue(fixedHeightS, fixedHeight);
}
if ( result && !rowSpacingS.isEmpty() ) {
- result = toPixels(rowSpacingS, rowSpacing);
- propertyAvailable |= HbDocumentLoaderActions::propertySpacing;
+ result = toLengthValue(rowSpacingS, rowSpacing);
}
- if ( result && propertyAvailable ) {
- result = mRealActions->setGridLayoutRowHeights( row, minHeight, maxHeight,
- prefHeight, fixedHeight,
- rowSpacing, propertyAvailable);
+ if ( result ) {
+ result = mActions->setGridLayoutRowHeights(
+ row, minHeight, maxHeight, prefHeight, fixedHeight, rowSpacing);
}
return result;
}
-bool HbDocumentLoaderSyntax::processColumnWidths( const QString &column )
+bool HbDocumentLoaderSyntax::processColumnWidths( int column )
{
const QString minWidthS = attribute( GL_MINWIDTH );
const QString maxWidthS = attribute( GL_MAXWIDTH );
const QString prefWidthS = attribute( GL_PREFWIDTH );
const QString fixedWidthS = attribute( GL_FIXEDWIDTH );
const QString columnSpacingS = attribute( GL_SPACING );
- qreal minWidth = -1;
- qreal maxWidth = -1;
- qreal prefWidth = -1;
- qreal fixedWidth = -1;
- qreal columnSpacing = -1;
+ HbXmlLengthValue minWidth, maxWidth, prefWidth, fixedWidth, columnSpacing;
bool result = true;
- int propertyAvailable = 0;
if ( !minWidthS.isEmpty() ) {
- result = toPixels(minWidthS, minWidth);
- propertyAvailable |= HbDocumentLoaderActions::propertyMin;
+ result = toLengthValue(minWidthS, minWidth);
}
if ( result && !maxWidthS.isEmpty() ) {
- result = toPixels(maxWidthS, maxWidth);
- propertyAvailable |= HbDocumentLoaderActions::propertyMax;
+ result = toLengthValue(maxWidthS, maxWidth);
}
if ( result && !prefWidthS.isEmpty() ) {
- result = toPixels(prefWidthS, prefWidth);
- propertyAvailable |= HbDocumentLoaderActions::propertyPref;
+ result = toLengthValue(prefWidthS, prefWidth);
}
if ( result && !fixedWidthS.isEmpty() ) {
- result = toPixels(fixedWidthS, fixedWidth);
- propertyAvailable |= HbDocumentLoaderActions::propertyFixed;
+ result = toLengthValue(fixedWidthS, fixedWidth);
}
if ( result && !columnSpacingS.isEmpty() ) {
- result = toPixels(columnSpacingS, columnSpacing);
- propertyAvailable |= HbDocumentLoaderActions::propertySpacing;
+ result = toLengthValue(columnSpacingS, columnSpacing);
}
- if ( result && propertyAvailable ) {
- result = mRealActions->setGridLayoutColumnWidths( column, minWidth, maxWidth,
- prefWidth, fixedWidth,
- columnSpacing, propertyAvailable);
+ if ( result ) {
+ result = mActions->setGridLayoutColumnWidths(
+ column, minWidth, maxWidth, prefWidth, fixedWidth, columnSpacing);
}
return result;
}
+bool HbDocumentLoaderSyntax::checkEndElementCorrectness()
+{
+ return HbXmlLoaderBaseSyntax::checkEndElementCorrectness();
+}
+
+
+
bool HbDocumentLoaderSyntax::readContainerStartItem()
{
bool result = false;
switch ( mCurrentElementType ) {
- case PROPERTY:
+ case HbXml::PROPERTY:
{
HB_DOCUMENTLOADER_PRINT( "CONTAINER START ITEM: PROPERTY" );
@@ -359,47 +608,26 @@
bool HbDocumentLoaderSyntax::readContainerEndItem()
{
+
bool result = false;
QString currentPropertyName;
QVariant variant;
switch( mCurrentElementType ) {
- case CONTAINER:
+ case HbXml::CONTAINER:
{
- currentPropertyName = mCurrentContainer.back();
- mCurrentContainer.removeLast();
+ currentPropertyName = mCurrentContainerNames.back();
+ mCurrentContainerNames.removeLast();
- if (mRealActions->mCurrentContainer) {
- // in order for the conversion to work, all of the contained types need to be suitable and equivalent, e.g. strings
- QVariant variantContainer = QVariant(*(mRealActions->mCurrentContainer));
- if (variantContainer.isValid()) {
- switch(mCurrentContainerType) {
- case CONTAINER_STRINGLIST:
- {
- QStringList list = variantContainer.toStringList();
- variant = QVariant(list);
- break;
- }
- default:
- {
- variant = variantContainer;
- break;
- }
- }
- }
- }
-
- result = mRealActions->pushProperty(currentPropertyName, variant);
+ result = mActions->pushContainer(currentPropertyName.toLatin1(), mCurrentContainerType, mCurrentContainer);
HB_DOCUMENTLOADER_PRINT( "CONTAINER END ITEM : SWITCHING TO GENERAL ITEM PROCESSING MODE" );
mElementState = ES_GENERAL_ITEM;
-
- result = true;
break;
}
default:
{
- result = HbXmlLoaderAbstractSyntax::readGeneralEndItem();
+ result = HbXmlLoaderBaseSyntax::readGeneralEndItem();
break;
}
}
@@ -410,49 +638,49 @@
{
bool result = false;
switch( mCurrentElementType ) {
- case OBJECT:
+ case HbXml::OBJECT:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: OBJECT" );
result = processObject();
break;
}
- case WIDGET:
+ case HbXml::WIDGET:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: WIDGET" );
result = processWidget();
break;
}
- case SPACERITEM:
+ case HbXml::SPACERITEM:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: SPACERITEM" );
result = processSpacerItem();
break;
}
- case CONNECT:
+ case HbXml::CONNECT:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: CONNECT" );
result = processConnect();
break;
}
- case PROPERTY:
+ case HbXml::PROPERTY:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: PROPERTY" );
result = processProperty();
break;
}
- case REF:
+ case HbXml::REF:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: REF" );
result = processRef();
break;
}
- case VARIABLE:
+ case HbXml::VARIABLE:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: VARIABLE" );
result = processVariable();
break;
}
- case DEPRECATED:
+ case HbXml::DEPRECATED:
{
HB_DOCUMENTLOADER_PRINT( "GENERAL START ITEM: DEPRECATED" );
result = true;
@@ -460,9 +688,12 @@
}
default:
{
- result = HbXmlLoaderAbstractSyntax::readGeneralStartItem();
+ result = HbXmlLoaderBaseSyntax::readGeneralStartItem();
}
}
+#ifdef LINE_DEBUGGING
+ debugPrint("MYTRACE: --- after line %d, time: %d", (int)mReader.lineNumber(), lineDebugTime.elapsed());
+#endif
return result;
}
@@ -501,7 +732,7 @@
return false;
}
- return mRealActions->pushDocument( attribute( ATTR_CONTEXT ) );
+ return mActions->pushDocument( attribute( ATTR_CONTEXT ) );
}
bool HbDocumentLoaderSyntax::processObject()
@@ -509,7 +740,8 @@
const QString type = attribute( ATTR_TYPE );
const QString name = attribute( ATTR_NAME );
- if( !mRealActions->pushObject( type, name ) ) {
+ bool pushOK = mActions->pushObject( type, name );
+ if( !pushOK ) {
qWarning() << "Error in object processing, line " << mReader.lineNumber();
return false;
}
@@ -522,7 +754,8 @@
const QString name = attribute( ATTR_NAME );
const QString role = attribute( ATTR_ROLE );
const QString plugin = attribute( ATTR_PLUGIN );
- if( !mRealActions->pushWidget( type, name, role, plugin) ) {
+ bool pushOK = mActions->pushWidget( type, name, role, plugin);
+ if( !pushOK ) {
qWarning() << "Error in widget processing, line " << mReader.lineNumber();
return false;
}
@@ -534,7 +767,8 @@
const QString name = attribute( ATTR_NAME );
const QString widget = attribute( ATTR_WIDGET );
- if( !mRealActions->pushSpacerItem( name, widget ) ) {
+ bool pushOK = mActions->pushSpacerItem( name, widget );
+ if( !pushOK ) {
qWarning() << "Error in object processing, line " << mReader.lineNumber();
return false;
}
@@ -550,21 +784,19 @@
if( layout_type == lexemValue( LAYOUT_ANCHOR ) ) {
mCurrentLayoutType = LAYOUT_ANCHOR;
- result = mRealActions->createAnchorLayout( widget );
+ result = mActions->createAnchorLayout( widget );
} else if( layout_type == lexemValue( LAYOUT_GRID ) ) {
result = true;
mCurrentLayoutType = LAYOUT_GRID;
const QString spacing = attribute( GL_SPACING );
- qreal spacingValue(0);
- qreal *spacingPtr(0);
+ HbXmlLengthValue spacingValue;
if( !spacing.isEmpty() ) {
- result = toPixels( spacing, spacingValue );
- spacingPtr = &spacingValue;
+ result = toLengthValue( spacing, spacingValue );
}
if (result) {
- result = mRealActions->createGridLayout( widget, spacingPtr );
+ result = mActions->createGridLayout( widget, spacingValue );
}
} else if( layout_type == lexemValue( LAYOUT_LINEAR ) ) {
@@ -572,29 +804,43 @@
result = true;
mCurrentLayoutType = LAYOUT_LINEAR;
const QString orientation = attribute( LL_ORIENTATION );
+
+
+ Qt::Orientation orient;
+ Qt::Orientation *orient_p = 0;
+ if (!orientation.isEmpty()) {
+ AccessToMetadata myAccess;
+ int value = myAccess.getEnumValue( "Orientation", orientation.toLatin1().data() );
+ if (value == -1) {
+ HB_DOCUMENTLOADER_PRINT( QString( "LINEARLAYOUT: NO SUCH ORIENTATION " ) + orientation );
+ result = false;
+ } else {
+ orient = (Qt::Orientation)value;
+ orient_p = &orient;
+ }
+ }
+
const QString spacing = attribute( LL_SPACING );
- qreal spacingValue(0);
- qreal *spacingPtr(0);
- if( !spacing.isEmpty() ) {
- result = toPixels( spacing, spacingValue );
- spacingPtr = &spacingValue;
+ HbXmlLengthValue spacingValue;
+ if( result && !spacing.isEmpty() ) {
+ result = toLengthValue( spacing, spacingValue );
}
if (result) {
- result = mRealActions->createLinearLayout( widget, orientation, spacingPtr );
+ result = mActions->createLinearLayout( widget, orient_p, spacingValue );
}
} else if( layout_type == lexemValue( LAYOUT_STACK ) ) {
mCurrentLayoutType = LAYOUT_STACK;
- result = mRealActions->createStackedLayout( widget );
+ result = mActions->createStackedLayout( widget );
} else if( layout_type == lexemValue( LAYOUT_NULL ) ) {
mCurrentLayoutType = LAYOUT_NULL;
- result = mRealActions->createNullLayout( widget );
+ result = mActions->createNullLayout( widget );
} else {
- return HbXmlLoaderAbstractSyntax::processLayout();
+ return HbXmlLoaderBaseSyntax::processLayout();
}
if( !result ) {
@@ -611,7 +857,8 @@
const QString dstName = attribute( ATTR_DST );
const QString slotName = attribute( ATTR_SLOT );
- if( !mRealActions->pushConnect( srcName, signalName, dstName, slotName ) ) {
+ bool pushOK = mActions->pushConnect( srcName, signalName, dstName, slotName );
+ if( !pushOK ) {
qWarning() << "Error in connect processing, line " << mReader.lineNumber();
return false;
@@ -621,7 +868,7 @@
bool HbDocumentLoaderSyntax::processContainer()
{
- bool result = false;
+ bool result = true;
const QString container_type = attribute( ATTR_TYPE );
if( container_type == lexemValue( CONTAINER_STRINGLIST ) ) {
@@ -629,46 +876,54 @@
mCurrentContainerType = CONTAINER_STRINGLIST;
const QString propertyName = attribute ( ATTR_NAME );
- mCurrentContainer << propertyName;
- result = mRealActions->createContainer();
-
+ if (propertyName.isEmpty()) {
+ qWarning() << "No property name defined, line " << mReader.lineNumber();
+ result = false;
+ }
+ if (result) {
+ mCurrentContainerNames << propertyName;
+ mCurrentContainer.clear();
+ }
} else {
- return HbXmlLoaderAbstractSyntax::processContainer();
+ result = HbXmlLoaderBaseSyntax::processContainer();
+ if( !result ) {
+ qWarning() << "Unable to create container, line " << mReader.lineNumber();
+ return false;
+ }
}
-
- if( !result ) {
- qWarning() << "Unable to create container, line " << mReader.lineNumber();
- return false;
- }
- return true;
+ return result;
}
bool HbDocumentLoaderSyntax::processContainedProperty()
{
- const QVariant value = decodeValue();
- if( ! value.isValid() ) {
+ HbXmlVariable *variable = new HbXmlVariable();
+ if ( !createVariable(*variable) ) {
qWarning() << "Invalid property, line " << mReader.lineNumber();
+ delete variable;
return false;
}
- if( !mRealActions->appendPropertyToContainer( value ) ) {
- qWarning() << "Unable to set property, line " << mReader.lineNumber();
- return false;
- }
+ mCurrentContainer.append(variable);
return true;
}
bool HbDocumentLoaderSyntax::processProperty()
{
- const QVariant value = decodeValue();
- if( ! value.isValid() ) {
+ HbXmlVariable variable;
+ if ( !createVariable(variable) ) {
qWarning() << "Invalid property, line " << mReader.lineNumber();
return false;
}
const QString propertyName = attribute( ATTR_NAME );
- if( !mRealActions->pushProperty( propertyName, value ) ) {
+ if( propertyName.isEmpty() ) {
+ qWarning() << "No property name defined, line " << mReader.lineNumber();
+ return false;
+ }
+
+ bool pushOK = mActions->pushProperty( propertyName.toLatin1(), variable );
+ if( !pushOK ) {
qWarning() << "Unable to set property, line " << mReader.lineNumber();
return false;
}
@@ -680,7 +935,8 @@
const QString objectName = attribute( ATTR_OBJECT );
const QString role = attribute( ATTR_ROLE );
- if( !mRealActions->pushRef( objectName, role ) ) {
+ bool pushOK = mActions->pushRef( objectName, role );
+ if( !pushOK ) {
qWarning() << "Error in reference processing, line " << mReader.lineNumber();
return false;
}
@@ -721,22 +977,22 @@
const QString bottomS = attribute( ATTR_BOTTOM );
result = true;
- qreal left = 0, top = 0, right = 0, bottom = 0;
+ HbXmlLengthValue left, top, right, bottom;
if ( !leftS.isEmpty() ) {
- result = toPixels(leftS, left);
+ result = toLengthValue(leftS, left);
}
if ( result && !topS.isEmpty() ) {
- result = toPixels(topS, top);
+ result = toLengthValue(topS, top);
}
if ( result && !rightS.isEmpty() ) {
- result = toPixels(rightS, right);
+ result = toLengthValue(rightS, right);
}
if ( result && !bottomS.isEmpty() ) {
- result = toPixels(bottomS, bottom);
+ result = toLengthValue(bottomS, bottom);
}
if ( result ) {
- result = mRealActions->setContentsMargins( left, top, right, bottom );
+ result = mActions->setContentsMargins( left, top, right, bottom );
}
if (!result) {
@@ -786,7 +1042,7 @@
}
if ( result ) {
- result = mRealActions->setSizePolicy( hPol, vPol, hStretch, vStretch );
+ result = mActions->setSizePolicy( hPol, vPol, hStretch, vStretch );
}
delete hPol;
delete vPol;
@@ -806,30 +1062,20 @@
result = true;
- qreal *sizeHintWidth = 0;
+ HbXmlLengthValue sizeHintWidth;
const QString width = attribute( ATTR_WIDTH );
if (!width.isEmpty()) {
- qreal widthInPixels;
- result = toPixels(width, widthInPixels);
- if (result) {
- sizeHintWidth = new qreal;
- *sizeHintWidth = widthInPixels;
- }
+ result = toLengthValue(width, sizeHintWidth);
}
- qreal *sizeHintHeight = 0;
+ HbXmlLengthValue sizeHintHeight;
const QString height = attribute( ATTR_HEIGHT );
if (result && !height.isEmpty()) {
- qreal heightInPixels;
- result = toPixels(height, heightInPixels);
- if (result) {
- sizeHintHeight = new qreal;
- *sizeHintHeight = heightInPixels;
- }
+ result = toLengthValue(height, sizeHintHeight);
}
if (result) {
- result = mRealActions->setSizeHint(hint, sizeHintWidth, sizeHintHeight, fixed);
+ result = mActions->setSizeHint(hint, sizeHintWidth, sizeHintHeight, fixed);
}
}
@@ -837,12 +1083,17 @@
qWarning() << "Invalid size hint, line " << mReader.lineNumber();
}
} else if ( type == lexemValue( TYPE_ZVALUE ) ) {
- const QString zValueAsString = attribute( ATTR_VALUE );
- if (!zValueAsString.isEmpty()) {
- qreal zValueAsReal;
- result = toReal(zValueAsString, zValueAsReal);
- if ( result ) {
- result = mRealActions->setZValue( zValueAsReal );
+ const QString value = attribute( ATTR_VALUE );
+ if (!value.isEmpty()) {
+ HbXmlLengthValue *value_res = new HbXmlLengthValue();
+ result = toLengthValue( value, *value_res );
+ if( result ) {
+ HbXmlVariable variable;
+ variable.mType = HbXmlVariable::REAL;
+ variable.mParameters.append( value_res );
+ result = mActions->pushProperty( ZValueProperty, variable );
+ } else {
+ delete value_res;
}
}
@@ -854,14 +1105,24 @@
const QString comment = attribute( ATTR_COMMENT );
const QString locId = attribute( ATTR_LOCID );
+ HbXmlVariable variable;
+
+ QString *param1 = new QString();
+ QString *param2 = new QString();
+
if (!locId.isEmpty()) {
- QByteArray locIdUtf8(locId.toUtf8());
- const QString translated = hbTrId(locIdUtf8);
- result = mRealActions->setToolTip( translated );
+ variable.mType = HbXmlVariable::STRING;
+ *param1 = value;
+ *param2 = locId;
} else {
- const QString translated = mRealActions->translate( value, comment );
- result = mRealActions->setToolTip( translated );
+ variable.mType = HbXmlVariable::LOCALIZED_STRING;
+ *param1 = value;
+ *param2 = comment;
}
+ variable.mParameters.append(param1);
+ variable.mParameters.append(param2);
+
+ result = mActions->setToolTip(variable);
if (!result) {
qWarning() << "Invalid tooltip, line " << mReader.lineNumber();
@@ -871,97 +1132,106 @@
return result;
}
-ElementType
+HbXml::ElementType
HbDocumentLoaderSyntax::elementType( QStringRef name ) const
{
const QString stringName = name.toString();
if( stringName == lexemValue(TYPE_DOCUMENT) ){
- return DOCUMENT;
+ return HbXml::DOCUMENT;
}
- return HbXmlLoaderAbstractSyntax::elementType( name );
+ return HbXmlLoaderBaseSyntax::elementType( name );
}
-QVariant HbDocumentLoaderSyntax::decodeValue()
+bool HbDocumentLoaderSyntax::createVariable( HbXmlVariable& variable )
{
- QVariant result = QVariant::Invalid;
+ const QString type = mReader.name().toString();
+ bool ok = true;
- const QString type = mReader.name().toString();
-
- bool ok = false;
if( type == lexemValue( TYPE_INT ) ) {
const QString value = attribute( ATTR_VALUE );
- int int_res = value.toInt( &ok );
- if( ok ) {
- result = int_res;
+ qint16 *int_res = new qint16();
+ *int_res = value.toInt( &ok );
+ if ( ok ) {
+ variable.mType = HbXmlVariable::INT;
+ variable.mParameters.append(int_res);
+ } else {
+ delete int_res;
}
} else if( type == lexemValue( TYPE_REAL ) ) {
const QString value = attribute( ATTR_VALUE );
- qreal qreal_res;
- ok = toPixels( value, qreal_res );
+ HbXmlLengthValue *value_res = new HbXmlLengthValue();
+ ok = toLengthValue( value, *value_res );
if( ok ) {
- result = qreal_res;
+ variable.mType = HbXmlVariable::REAL;
+ variable.mParameters.append(value_res);
+ } else {
+ delete value_res;
}
} else if( type == lexemValue( TYPE_LOCALIZED_STRING ) ) {
- const QString value =
- mRealActions->translate( attribute( ATTR_VALUE ), attribute( ATTR_COMMENT ) );
- result = value;
+ QString *value = new QString();
+ QString *attr = new QString();
+ *value = attribute( ATTR_VALUE );
+ *attr = attribute( ATTR_COMMENT );
+ variable.mType = HbXmlVariable::LOCALIZED_STRING;
+ variable.mParameters.append(value);
+ variable.mParameters.append(attr);
} else if( type == lexemValue( TYPE_STRING ) ) {
- const QString value = attribute( ATTR_VALUE );
- const QString locId = attribute( ATTR_LOCID );
- if (!locId.isEmpty()) {
- QByteArray locIdUtf8(locId.toUtf8());
- result = hbTrId(locIdUtf8);
- } else {
- result = value;
- }
- } else if( type == lexemValue( TYPE_ENUMS ) ) {
- result = attribute( ATTR_VALUE );
+ QString *value = new QString();
+ QString *locId = new QString();
+ *value = attribute( ATTR_VALUE );
+ *locId = attribute( ATTR_LOCID );
+ variable.mType = HbXmlVariable::STRING;
+ variable.mParameters.append(value);
+ variable.mParameters.append(locId);
+ } else if( type == lexemValue( TYPE_ENUMS ) || type == lexemValue(TYPE_ALIGNMENT) || type == lexemValue(LL_ORIENTATION) ) {
+ QString *value = new QString();
+ *value = attribute( ATTR_VALUE );
+ variable.mType = HbXmlVariable::ENUMS;
+ variable.mParameters.append(value);
} else if ( type == lexemValue( TYPE_BOOL ) ) {
+ bool *boolVal = new bool();
const QString value = attribute( ATTR_VALUE );
if (value == lexemValue( VALUE_BOOL_TRUE ) ) {
- result = QVariant(true);
+ *boolVal = true;
} else if (value == lexemValue( VALUE_BOOL_FALSE ) ) {
- result = QVariant(false);
+ *boolVal = false;
+ } else {
+ ok = false;
+ }
+ if (ok) {
+ variable.mType = HbXmlVariable::BOOL;
+ variable.mParameters.append(boolVal);
+ } else {
+ delete boolVal;
}
} else if ( type == lexemValue( TYPE_ICON ) ) {
- HbIcon icon;
- ok = true;
-
- // Read optional iconName attribute (if not given, it's null icon)
- const QString iconName = attribute( ATTR_ICONNAME );
- if ( !iconName.isEmpty() ) {
- icon.setIconName( iconName );
- }
-
- qreal desiredWidth = 0;
- qreal desiredHeight = 0;
+ QString *iconName = new QString(attribute( ATTR_ICONNAME ));
+ HbXmlLengthValue *desiredWidth = new HbXmlLengthValue();
+ HbXmlLengthValue *desiredHeight = new HbXmlLengthValue();
// Read optional width attribute
const QString width = attribute( ATTR_WIDTH );
if (!width.isEmpty()) {
- ok = toPixels( width, desiredWidth );
+ ok = toLengthValue( width, *desiredWidth );
}
// Read optional height attribute
const QString height = attribute( ATTR_HEIGHT );
if (ok && !height.isEmpty()) {
- ok = toPixels( height, desiredHeight );
+ ok = toLengthValue( height, *desiredHeight );
}
if (ok) {
- if (!width.isEmpty() && !height.isEmpty()) {
- icon.setSize(QSizeF(desiredWidth, desiredHeight));
- } else if (!width.isEmpty()) {
- icon.setWidth(desiredWidth);
- } else if (!height.isEmpty()) {
- icon.setHeight(desiredHeight);
- } else {
- // neither defined.
- }
-
- result = icon;
+ variable.mType = HbXmlVariable::ICON;
+ variable.mParameters.append(iconName);
+ variable.mParameters.append(desiredWidth);
+ variable.mParameters.append(desiredHeight);
+ } else {
+ delete iconName;
+ delete desiredWidth;
+ delete desiredHeight;
}
} else if ( type == lexemValue(TYPE_SIZE) ) {
@@ -969,18 +1239,22 @@
const QString height = attribute( ATTR_HEIGHT );
if (!width.isEmpty() && !height.isEmpty()) {
- ok = true;
- QSizeF size;
- qreal widthVal, heightVal;
- ok = toPixels(width, widthVal);
+ HbXmlLengthValue *widthVal = new HbXmlLengthValue();
+ HbXmlLengthValue *heightVal = new HbXmlLengthValue();
+ ok = toLengthValue(width, *widthVal);
if (ok) {
- size.setWidth(widthVal);
- ok = toPixels(height, heightVal);
+ ok = toLengthValue(height, *heightVal);
}
if (ok) {
- size.setHeight(heightVal);
- result = size;
+ variable.mType = HbXmlVariable::SIZE;
+ variable.mParameters.append(widthVal);
+ variable.mParameters.append(heightVal);
+ } else {
+ delete widthVal;
+ delete heightVal;
}
+ } else {
+ ok = false;
}
} else if ( type == lexemValue(TYPE_RECT) ) {
@@ -991,27 +1265,34 @@
const QString height = attribute( ATTR_HEIGHT );
if (!width.isEmpty() && !height.isEmpty() && !posx.isEmpty() && !posy.isEmpty()) {
- ok = true;
- QSizeF size;
- QPointF point;
- qreal widthVal, heightVal, posxVal, posyVal;
- ok = toPixels(width, widthVal);
+ HbXmlLengthValue *widthVal = new HbXmlLengthValue();
+ HbXmlLengthValue *heightVal = new HbXmlLengthValue();
+ HbXmlLengthValue *posxVal = new HbXmlLengthValue();
+ HbXmlLengthValue *posyVal = new HbXmlLengthValue();
+ ok = toLengthValue(width, *widthVal);
if (ok) {
- size.setWidth(widthVal);
- ok = toPixels(height, heightVal);
+ ok = toLengthValue(height, *heightVal);
+ }
+ if (ok) {
+ ok = toLengthValue(posx, *posxVal);
}
if (ok) {
- size.setHeight(heightVal);
- ok = toPixels(posx, posxVal);
+ ok = toLengthValue(posy, *posyVal);
}
if (ok) {
- point.setX(posxVal);
- ok = toPixels(posy, posyVal);
+ variable.mType = HbXmlVariable::RECT;
+ variable.mParameters.append(widthVal);
+ variable.mParameters.append(heightVal);
+ variable.mParameters.append(posxVal);
+ variable.mParameters.append(posyVal);
+ } else {
+ delete widthVal;
+ delete heightVal;
+ delete posxVal;
+ delete posyVal;
}
- if (ok) {
- point.setY(posyVal);
- result = QRectF(point, size);
- }
+ } else {
+ ok = false;
}
} else if ( type == lexemValue(TYPE_POINT) ) {
@@ -1019,74 +1300,69 @@
const QString posx = attribute( ATTR_X );
const QString posy = attribute( ATTR_Y );
if (!posx.isEmpty() && !posy.isEmpty()) {
- ok = true;
- QPointF point;
- qreal posxVal, posyVal;
- ok = toPixels(posx, posxVal);
+ HbXmlLengthValue *posxVal = new HbXmlLengthValue();
+ HbXmlLengthValue *posyVal = new HbXmlLengthValue();
+ ok = toLengthValue(posx, *posxVal);
if (ok) {
- point.setX(posxVal);
- ok = toPixels(posy, posyVal);
+ ok = toLengthValue(posy, *posyVal);
}
if (ok) {
- point.setY(posyVal);
- result = point;
+ variable.mType = HbXmlVariable::POINT;
+ variable.mParameters.append(posxVal);
+ variable.mParameters.append(posyVal);
+ } else {
+ delete posxVal;
+ delete posyVal;
}
- }
-
- } else if ( type == lexemValue(TYPE_ALIGNMENT) ) {
-
- const QString alignment = attribute( ATTR_VALUE );
- if (!alignment.isEmpty() ) {
- result = alignment;
- }
-
- } else if ( type == lexemValue(LL_ORIENTATION) ) {
-
- const QString orientation = attribute( ATTR_VALUE );
- if (!orientation.isEmpty() ) {
- result = orientation;
+ } else {
+ ok = false;
}
} else if ( type == lexemValue(TYPE_COLOR) ) {
const QString curColor = attribute( ATTR_VALUE );
if (!curColor.isEmpty() ) {
- ok = true;
- result = QColor(curColor);
+ QColor *colorVal = new QColor(curColor);
+ variable.mType = HbXmlVariable::COLOR;
+ variable.mParameters.append(colorVal);
+ } else {
+ ok = false;
}
} else if ( type == lexemValue(TYPE_FONTSPEC) ) {
QString roleString = attribute( ATTR_FONTSPECROLE );
HbFontSpec::Role role(HbFontSpec::Undefined);
- ok = true;
if (!roleString.isEmpty()) {
ok = toFontSpecRole(roleString, role); // sets role if ok
}
if (ok) {
- HbFontSpec spec(role);
+ quint8 *role_b = new quint8();
+ *role_b = (quint8)role;
+ HbXmlLengthValue *height = new HbXmlLengthValue();
QString textHeightString = attribute( ATTR_TEXTHEIGHT );
if (textHeightString.isEmpty()) {
// Deprecated.
textHeightString = attribute( ATTR_TEXTPANEHEIGHT );
}
if (!textHeightString.isEmpty()) {
- qreal height(0);
- ok = toPixels(textHeightString, height);
- if (ok) {
- spec.setTextHeight(qRound(height));
- }
+ ok = toLengthValue(textHeightString, *height);
}
if (ok) {
- result = spec;
+ variable.mType = HbXmlVariable::FONTSPEC;
+ variable.mParameters.append(role_b);
+ variable.mParameters.append(height);
+ } else {
+ delete role_b;
+ delete height;
}
}
}
else {
// unknown property.
+ ok = false;
}
-
- return result;
+ return ok;
}
bool HbDocumentLoaderSyntax::convertSizeHintType(