if (mFile) {

        delete mFile;

    }

    mFilePath = path;

    QString filePath(":typefaces.xml");

    // If one has been set by API

    if ( !mFilePath.isEmpty() ) {

        filePath = mFilePath;

    }

    else {

    // Check if resource directory has got the typefaces.xml file.

    // If yes, then use the one present in the resource directory

        QString resourceFilePath(TYPEFACE_RESOURCE_FOLDER);

        resourceFilePath.append(QDir::separator());

        resourceFilePath.append("typefaces.xml"); 

        QFile *file = new QFile(resourceFilePath);

        if( file && file->exists() ) {

            filePath = resourceFilePath;

        }

        delete file;

    }   

    if (mFile){

        delete mFile;

    }

    mFile = new QFile(filePath);

    // Trying to see if the absolute path can be determined

    QString name2 = mFile->fileName();

    if( !mFile->exists() ) {

        qWarning("HbTypefaceXmlParser Warning: XML-file at %s does not exist", qPrintable(filePath));

        return false;

    }

    // not yet parsed, parse and add data

    if (!mFile->open(QFile::ReadOnly | QFile::Text)) {

        qWarning("HbEffect Warning: XML-file at %s opening failed", qPrintable(filePath));

        return false;

    }

    setDevice(mFile);

    bool positioned(false);

    while (!atEnd() && !positioned) {

        QXmlStreamReader::TokenType type = readNext();

        if (isStartElement()) {

            if (name() == TYPEFACE_INFO) {

                positioned = true;

            }

            else {

                raiseError("HbTypefaceXmlParser::read The document is not a valid typeface information xml file.");

            }

        }

    }

    return !error() && positioned;

    Q_ASSERT(isStartElement() && name() == TYPEFACE_INFO);

    bool positioned(false);

    while (!atEnd() && !positioned) {

        QXmlStreamReader::TokenType type = readNext();

        if (isStartElement()) {

            if (name() == TYPEFACE_SET) {

                // find the correct language and country

                positioned = matchLanguageAndCountry();

            }

        }

    }

    return positioned;

    Q_ASSERT(isStartElement() && name() == TYPEFACE_SET);

    QString language, country;

    bool positioned(false);

    HbExtendedLocale systemLocale = HbExtendedLocale::system();

    QString attrName, typefaceLocaleName, systemLocaleName;

    QXmlStreamAttributes attrs = attributes();

    foreach (const QXmlStreamAttribute &attr, attrs) {

        attrName = attr.name().toString();

        if (attrName == TYPEFACE_LANGUAGE_ATT) {

            language = attr.value().toString().toLower();

        }

        else if (attrName == TYPEFACE_COUNTRY_ATT) {

            country = attr.value().toString().toUpper();

        }

        else {

            qDebug("Unrecognized attribute");

        }

    }

    // Construct the locale with the typeface locale info

    if (!language.isEmpty()) {

        if (!country.isEmpty()) {

            typefaceLocaleName = language + '_' + country;

            systemLocaleName = systemLocale.name();

        }

        else {

            typefaceLocaleName = language;

            // Language is a lowercase, two-letter, ISO 639 language code

            systemLocaleName = systemLocale.name().left(2);

        }

    }

    else {

        positioned = true;

    }

    if (!positioned && typefaceLocaleName.compare(systemLocaleName, Qt::CaseInsensitive) == 0) {

        positioned = true;

    }

    return positioned;

    StartElement startElement(NoStartElement);

    bool atEnd(false);

        QXmlStreamReader::TokenType type = readNext();

        if (isStartElement()) {

            if (name() == TYPEFACE_METRICS) {

                startElement = TypefaceMetrics;

                // Grab the typeface name as "current"

                QXmlStreamAttributes attrs = attributes();

                foreach (const QXmlStreamAttribute &attr, attrs) {

                    if (attr.name().toString() == TYPEFACE_FAMILY_ATT) {

                        mCurrentFamily = attr.value().toString();

                        if (!mCurrentFamily.isEmpty()) {

                            startElement = TypefaceMetrics; // Now we have a workable start element

                        }

                    }

                }

            }

            else if ( name() == TYPEFACE_SET) {

                startElement = TypefaceSet;

            }

        }

        else {

            // Nothing. Some other type of element;

        }

    \sa init()

    bool atEnd(false);

    bool success(false);

        QXmlStreamReader::TokenType type = readNext();

        if (isEndElement()) {

            if(name() == TYPEFACE_SET) {

                atEnd = true;

            }

        }

        else if (isStartElement()) {

            if (name() == TYPEFACE_MAPPING) {

                success = readMapItem(role, family, aliasFamily, bold);

            }

        }

        else {

            // Nothing. Some other type of element;

        }

    QXmlStreamAttributes attrs = attributes();

    foreach (const QXmlStreamAttribute &attr, attrs) {

        attrName = attr.name().toString();

        if (attrName == TYPEFACE_ROLE_ATT) {

            role = attr.value().toString();

                haveRole = true;

        }

        else if (attrName == TYPEFACE_FAMILY_ATT) {

            family = attr.value().toString();

                haveFamily = true;

        }

        else if (attrName == TYPEFACE_WEIGHT_ATT) {

            if (attr.value().toString() == TYPEFACE_ATT_VAL_BOLD)

                isBold = true;

        }

        else if (attrName == TYPEFACE_ALIASFAMILY_ATT) {

            aliasFamily = attr.value().toString();

        }

        else {

            qDebug("Unrecognized attribute");

        }

    bool atEnd(false);

    bool success(false);

    textHeight = -1;

    size = -1;

    baseline = -1;

        QXmlStreamReader::TokenType type = readNext();

        if (isEndElement()) {

            if(name() == TYPEFACE_METRICS) {

                atEnd = true;

            }

        }

        else if (isStartElement()) {

            if (name() == TYPEFACE_METRICS_POINT) {

                success = readMetricItem(textHeight, size, baseline);

            }

        }

        else {

            // Nothing. Some other type of element;

        }

    QXmlStreamAttributes attrs = attributes();

    foreach (const QXmlStreamAttribute &attr, attrs) {

        attrName = attr.name().toString();

        attrValue = attr.value().toString();

        if (attrName == TYPEFACE_TEXTHEIGHT_ATT) {

            textHeight = attrValue.toInt();

        }

        else if (attrName == TYPEFACE_SIZE_ATT) {

            size = attrValue.toInt();

        }

        else if (attrName == TYPEFACE_BASELINE_ATT) {

            baseline = attrValue.toInt();

        }

        else {

            qDebug() << "Unrecognized attribute: " << attrName;

        }

    clear();

    if (mFile && mFile->isOpen()) {

            mFile->close(); // Device is owned externally from streamreader

    }

    return mCurrentFamily;