/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include <QPluginLoader>

#include <QDir>

#include <QLibrary>

#include <QTextStream>

#include <QVector>

#include "hbinputkeymap.h"

#include "hbinputsettingproxy.h"

/// @cond

class HbKeymapFactoryPrivate

{

public:

    HbKeymapFactoryPrivate();

    ~HbKeymapFactoryPrivate();

public:

    QList<HbInputLanguage> mRomLanguages;

};

HbKeymapFactoryPrivate::HbKeymapFactoryPrivate()

{

}

HbKeymapFactoryPrivate::~HbKeymapFactoryPrivate()

{

        delete keymap;

    }

    mKeymaps.clear();

    mRomLanguages.clear();

}

{

    bool ok = false;

    QLocale::Language language = QLocale::C;

    QLocale::Country country = QLocale::AnyCountry;

        int underscorePos = file.indexOf('_');

        int periodPos = file.indexOf('.');

        if (underscorePos > 0 && underscorePos < periodPos) {

            language = static_cast<QLocale::Language>(file.left(underscorePos).toUInt(&ok));

            if (!ok) {

                continue;

            }

            if (!ok) {

                continue;

            }

            HbInputLanguage toAdd(language, country);

            if (!languages.contains(toAdd)) {

                languages.append(toAdd);

            }

        } else if (periodPos > 0) {

            language = static_cast<QLocale::Language>(file.left(periodPos).toUInt(&ok));

            if (!ok) {

                continue;

            }

            HbInputLanguage toAdd(language);

            if (!languages.contains(toAdd)) {

                languages.append(toAdd);

            }

        }

    }

}

    QTextStream stream(&file);

    HbKeyboardType keyboardType = HbKeyboardNone;

    bool retunResult = false;

    while (!stream.atEnd()) {

        QString line = stream.readLine();

        if (keyboardType == HbKeyboardSctPortrait || keyboardType == HbKeyboardSctLandscape) {

            continue;

        // When an empty line is encountered, an ongoing keyboard definition ends

        if (line.isEmpty()) {

            if (keyboardType != HbKeyboardNone) {

                keyboardType = HbKeyboardNone;

            }

            continue;

        }

        // Line starting with "//" is a comment

        if (line.length() >= 2 && line.at(0) == '/' && line.at(1) == '/') {

            continue;

        }

        // Non-empty line without ongoing keyboard definition is the start of a definition,

        // containing the keyboard type as hex

        if (keyboardType == HbKeyboardNone) {

            bool ok = false;

            if (ok) {

                keyboardType = static_cast<HbKeyboardType>(keyType);

            }

            retunResult = true;

        } else {

            if (splitResult.count() == 0) {

                continue;

            if ((splitResult.count() < 2 || splitResult.count() > 5)) {

                retunResult = false;

                break;

            }

        }

    }

    //Make the Reading position at the start of the file

    return retunResult;

}

{

    QTextStream stream(&file);

    while (!stream.atEnd()) {

        QString line = stream.readLine();

        if (line.isEmpty() || (line.length() >= 2 && line.at(0) == '/' && line.at(1) == '/')) {

            continue;

        }

            QStringList periodSplits = splitResult.at(1).split('.');

            QString version = periodSplits.at(0);

            version.append('.');

            while (i < count) {

            }

            versionNumber = version.toFloat();

            break;

        } else {

            QString filename = file.fileName();

            if (filename.left(2) == ":/" || filename.left(2).toLower() == "z:") {

                versionNumber = 0;

                break;

        }

    }

    //Make the Reading position at the start of the file

    stream.seek(0);

    return versionNumber;

}

/// @endcond

/*!

@alpha

@hbcore

\class HbKeymapFactory

\brief A factory class for accessing keymap data.

Keymap factory constructs HbKeymap objects for given languages based on keymap resource files.

It can also provide a list of available keymap files in the system.

\sa HbKeymap

*/

/*!

Returns reference to singleton instance.

*/

{

    static HbKeymapFactory myInstance;

    return &myInstance;

}

/*!

Constructs the object.

*/

HbKeymapFactory::HbKeymapFactory()

{

    mPrivate = new HbKeymapFactoryPrivate();

}

/*!

Destructs the object.

*/

HbKeymapFactory::~HbKeymapFactory()

{

    delete mPrivate;

}

/*!

HbKeymap object remains with HbKeymapFactory.

If no data is found for the given language, 0 is returned.

\param language Language for the keymap

\param country Country for the keymap. If empty or AnyCountry, non-country specific version or a country-specific version will be returned.

\sa HbKeymap

*/

{

    return keymap(HbInputLanguage(language, country));

}

/*!

HbKeymap object remains with HbKeymapFactory.

If no data is found for the given input language, 0 is returned. If the variant of the input language

is AnyCountry, the function can return either a keymap with no variant specified or a keymap with any variant.

\param language HbInputLanguage defining the language-country combination.

\sa HbKeymap

\sa HbInputLanguage

*/

{

        if (keymap->language() == language) {

            return keymap;

        }

    }

    QString filename, latestVersionFilename;

    QFile file;

        if (language.variant() == QLocale::AnyCountry) {

            filename = path + '/' + QString::number(language.language()) + ".txt";

        } else {

        }

        if (QFile::exists(filename)) {

            file.setFileName(filename);

            if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {

                if ((fileVersion > maxVersionNumber) && mPrivate->isValidKeymap(file)) {

                    //Found the valid keymap with latest version

                    latestVersionFilename = filename;

                    maxVersionNumber = fileVersion;

                //Close the file

                file.close();

    }

    file.setFileName(latestVersionFilename);

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {

                }

    QTextStream stream(&file);

    while (!stream.atEnd()) {

        QString line = stream.readLine();

        // When an empty line is encountered, an ongoing keyboard definition ends

        if (line.isEmpty()) {

            if (keyboard) {

                if (!keymap) {

                    keymap = new HbKeymap(language);

                }

                keymap->addKeyboard(keyboard);

                keyboard = 0;

            }

            continue;

        }

        // Line starting with "//" is a comment

        if (line.length() >= 2 && line.at(0) == '/' && line.at(1) == '/') {

            continue;

        }

        // Non-empty line without ongoing keyboard definition is the start of a definition,

        // containing the keyboard type as hex

        if (!keyboard) {

            bool ok = false;

            int keyType = line.toInt(&ok, 16);

            if (ok) {

                keyboard = new HbKeyboardMap();

                keyboard->type = static_cast<HbKeyboardType>(keyType);

            }

        } else {

            if (splitResult.count() == 0) {

                continue;

            }

            mappedKey->keycode = splitResult.at(0).at(0);

            for (int i = 1; i < splitResult.count(); ++i) {

                switch (i) {

                case 1:

                    mappedKey->chars.append(splitResult.at(1));

                    break;

                case 2:

                    mappedKey->chars.append(splitResult.at(2));

                    break;

                case 3:

                    mappedKey->chars.append(splitResult.at(3));

                    break;

                case 4:

                    mappedKey->chars.append(splitResult.at(4));

                    break;

                default:

                    break;

                }

            }

            keyboard->keys.append(mappedKey);

        }

    }

    if (keymap) {

        mPrivate->mKeymaps.append(keymap);

    }

    file.close();

    return keymap;

}

/*!

Returns a list of available languages (or keymap data files) in the system.

\sa HbInputLanguage

*/

QList<HbInputLanguage> HbKeymapFactory::availableLanguages()

{

    bool romLanguagesCached = !instance->mPrivate->mRomLanguages.isEmpty();

    QList<HbInputLanguage> languages;

    QStringList files;

    QStringList romFiles;

        if (path.left(2) == ":/" || path.left(2) == "z:") {

            if (romLanguagesCached) {

                continue;

            }

            QDir languagedir(path);

            romFiles += languagedir.entryList(QStringList(QString("*.txt")), QDir::Files);

        } else {

            QDir languagedir(path);

            files += languagedir.entryList(QStringList(QString("*.txt")), QDir::Files);

        }

    }

    if (romLanguagesCached) {

        languages = instance->mPrivate->mRomLanguages;

    } else {

        instance->mPrivate->parseFiles(romFiles, languages);

        instance->mPrivate->mRomLanguages = languages;

    }

    instance->mPrivate->parseFiles(files, languages);

    return languages;

}

// End of file