Mercurial Mercurial > oss > FCL > sf > mw > hb / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/hbcore/utils/hbxmlloaderabstractsyntax_p.cpp
changeset 28 b7da29130b0e
parent 7 923ff622b8b9
child 30 80e4d18b72f5
equal deleted inserted replaced
23:e6ad4ef83b23 28:b7da29130b0e 
    22 ** Nokia at developer.feedback@nokia.com.
 
    22 ** Nokia at developer.feedback@nokia.com.
 
    23 **
 
    23 **
 
    24 ****************************************************************************/
 
    24 ****************************************************************************/
 
    25 
    25 
    26 #include "hbxmlloaderabstractsyntax_p.h"
 
    26 #include "hbxmlloaderabstractsyntax_p.h"
 
       
    27 #include "hbhash_p.h"
 
    27 
    28 
    28 #include <QColor>
 
    29 #include <QColor>
 
    29 #include <QDataStream>
 
    30 #include <QDataStream>
 
    30 #include <QDebug>
 
    31 #include <QDebug>
 
    31 
    32 
   192             double f_value = (double)value.mValue; //krazy:exclude=typedefs
 
   193             double f_value = (double)value.mValue; //krazy:exclude=typedefs
 
   193             stream << f_value;
 
   194             stream << f_value;
 
   194             break;
 
   195             break;
 
   195             }
 
   196             }
 
   196         case HbXmlLengthValue::Variable:
 
   197         case HbXmlLengthValue::Variable:
 
       
   198         case HbXmlLengthValue::VariableNegative:
 
       
   199             {
 
       
   200             stream << value.mHashValue;
 
       
   201             break;
 
       
   202             }
 
   197         case HbXmlLengthValue::Expression:
 
   203         case HbXmlLengthValue::Expression:
 
       
   204         case HbXmlLengthValue::ExpressionNegative:
 
   198             stream << value.mString;
 
   205             stream << value.mString;
 
   199             break;
 
   206             break;
 
   200         default:
 
   207         default:
 
   201             break;
 
   208             break;
 
   202     }
 
   209     }
 
   220             stream >> f_value;
 
   227             stream >> f_value;
 
   221             value.mValue = f_value;
 
   228             value.mValue = f_value;
 
   222             break;
 
   229             break;
 
   223             }
 
   230             }
 
   224         case HbXmlLengthValue::Variable:
 
   231         case HbXmlLengthValue::Variable:
 
       
   232         case HbXmlLengthValue::VariableNegative:
 
       
   233             stream >> value.mHashValue;
 
       
   234             break;
 
   225         case HbXmlLengthValue::Expression:
 
   235         case HbXmlLengthValue::Expression:
 
       
   236         case HbXmlLengthValue::ExpressionNegative:
 
   226             stream >> value.mString;
 
   237             stream >> value.mString;
 
   227             break;
 
   238             break;
 
   228         default:
 
   239         default:
 
   229             break;
 
   240             break;
 
   230     }
 
   241     }
 
   592 }
 
   603 }
 
   593 
   604 
   594 bool HbXmlLoaderAbstractSyntax::toLengthValue(const QString &value, HbXmlLengthValue& lengthVal) const
 
   605 bool HbXmlLoaderAbstractSyntax::toLengthValue(const QString &value, HbXmlLengthValue& lengthVal) const
 
   595 {
 
   606 {
 
   596     bool retVal(true);
 
   607     bool retVal(true);
 
   597     QString val = value;
 
   608     quint32 hashValue(0);
 
   598     val.reserve(val.length());
 
       
   599     HbXmlLengthValue::Type type = HbXmlLengthValue::PlainNumber;
 
   609     HbXmlLengthValue::Type type = HbXmlLengthValue::PlainNumber;
 
   600     if ( val.endsWith(lexemValue(UNIT_UNIT), Qt::CaseInsensitive) ) {
 
   610     if ( value.endsWith(lexemValue(UNIT_UNIT), Qt::CaseInsensitive) ) {
 
   601         type = HbXmlLengthValue::Unit;
 
   611         type = HbXmlLengthValue::Unit;
 
   602     } else if ( val.endsWith(lexemValue(UNIT_PIXEL), Qt::CaseInsensitive) ) {
 
   612     } else if ( value.endsWith(lexemValue(UNIT_PIXEL), Qt::CaseInsensitive) ) {
 
   603         type = HbXmlLengthValue::Pixel;
 
   613         type = HbXmlLengthValue::Pixel;
 
   604     } else if ( val.endsWith(lexemValue(UNIT_MILLIMETER), Qt::CaseInsensitive) ) {
 
   614     } else if ( value.endsWith(lexemValue(UNIT_MILLIMETER), Qt::CaseInsensitive) ) {
 
   605         type = HbXmlLengthValue::Millimeter;
 
   615         type = HbXmlLengthValue::Millimeter;
 
   606     } else if ( (val.startsWith( lexemValue(UNIT_VAR_START) ) ||
 
   616     } else if ( value.startsWith( lexemValue(UNIT_VAR_START) ) && value.endsWith( lexemValue(UNIT_VAR_END) ) ) {
 
   607                 val.startsWith( lexemValue(UNIT_VAR_NEG_START) ) ) && val.endsWith( lexemValue(UNIT_VAR_END) ) ) {
 
       
   608         type = HbXmlLengthValue::Variable;
 
   617         type = HbXmlLengthValue::Variable;
 
   609     } else if ( (val.startsWith( lexemValue(UNIT_EXPR_START) ) ||
 
   618         hashValue = hbHash(value.midRef(4,value.length()-5));
 
   610                 val.startsWith( lexemValue(UNIT_EXPR_NEG_START) )) && val.endsWith( lexemValue(UNIT_EXPR_END) ) ) {
 
   619     } else if ( value.startsWith( lexemValue(UNIT_VAR_NEG_START) ) && value.endsWith( lexemValue(UNIT_VAR_END) ) ) {
 
       
   620         type = HbXmlLengthValue::VariableNegative;
 
       
   621         hashValue = hbHash(value.midRef(5,value.length()-6));
 
       
   622     } else if ( value.startsWith( lexemValue(UNIT_EXPR_START) ) && value.endsWith( lexemValue(UNIT_EXPR_END) ) ) {
 
   611         type = HbXmlLengthValue::Expression;
 
   623         type = HbXmlLengthValue::Expression;
 
       
   624     } else if ( value.startsWith( lexemValue(UNIT_EXPR_NEG_START) ) && value.endsWith( lexemValue(UNIT_EXPR_END) ) ) {
 
       
   625         type = HbXmlLengthValue::ExpressionNegative;
 
   612     }
 
   626     }
 
   613     lengthVal.mType = type;
 
   627     lengthVal.mType = type;
 
   614     if ( type == HbXmlLengthValue::Variable || type == HbXmlLengthValue::Expression ) {
 
   628     lengthVal.mString = QString();
 
   615         lengthVal.mString = value;
 
   629 
   616         lengthVal.mValue = 0;
 
   630     switch ( type ) {
 
   617     } else {
 
   631         case HbXmlLengthValue::None:
 
   618         lengthVal.mString = QString();
 
   632             break;
 
   619         if (type != HbXmlLengthValue::PlainNumber) {
 
   633         case HbXmlLengthValue::PlainNumber:
 
   620             // Assuming all unit identifiers have two characters
 
   634             retVal = toReal( value, lengthVal.mValue );
 
   621             val.chop(2);
 
   635             break;
 
   622         }
 
   636         case HbXmlLengthValue::Pixel:
 
   623         retVal = toReal( val, lengthVal.mValue );
 
   637         case HbXmlLengthValue::Unit:
 
       
   638         case HbXmlLengthValue::Millimeter:
 
       
   639             retVal = toReal( QString::fromRawData( value.constData(), value.length()-2 ), lengthVal.mValue );
 
       
   640             break;
 
       
   641         case HbXmlLengthValue::Variable:
 
       
   642         case HbXmlLengthValue::VariableNegative:
 
       
   643             lengthVal.mHashValue = hashValue;
 
       
   644             break;
 
       
   645         case HbXmlLengthValue::Expression:
 
       
   646         case HbXmlLengthValue::ExpressionNegative:
 
       
   647             lengthVal.mString = value;
 
       
   648             lengthVal.mValue = 0;
 
       
   649             break;
 
       
   650         default:
 
       
   651             break;
 
   624     }
 
   652     }
 
   625     return retVal;
 
   653     return retVal;
 
   626 }
 
   654 }
 
   627 
   655 
   628 const char *HbXmlLoaderAbstractSyntax::lexemValue(DocumentLexems lex) const
 
   656 const char *HbXmlLoaderAbstractSyntax::lexemValue(DocumentLexems lex) const
FCL/sf/mw/hb