/*
* Copyright (c) 2008 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:  This is the implementation of application class
*
*/


#include <e32std.h>
#include <e32svr.h>

#include "hidlayoutids.h"
#include "mapping.h"
#include "layout.h"
#include "debug.h"

// ----------------------------------------------------------------------

const TInt TFindLayoutId::KDefaultLayoutId = EUnitedKingdom;

// ----------------------------------------------------------------------
// Map a HID country ID to a keyboard layout ID:
//
const TFindLayoutId::TCountryMapEntry TFindLayoutId::KMapCountryToLayout[] =
    {
        // HID ID -> Standard layout ID
        //
        {  2, EBelgian               }, // Belgian
        {  6, EDanish                }, // Danish
        {  7, EFinnishSwedish        }, // Finnish
        {  8, EFrench                }, // French
        {  9, EGerman                }, // German
        { 14, EItalian               }, // Italian
        { 18, EDutch                 }, // Netherlands/Dutch
        { 19, ENorwegian             }, // Norwegian
        { 22, EPortuguese            }, // Portuguese
        { 25, ESpanish               }, // Spanish
        { 26, EFinnishSwedish        }, // Swedish
        { 32, EUnitedKingdom         }, // UK
        { 33, EUnitedStates          }, // US
        //
        // Not in requirements, but layouts do exist. (Note that it
        // doesn't matter if a layout is listed here but isn't installed,
        // as the default layout will be used instead.)
        //
        { 4, ECanadianFrench         }, // Canadian-French
        {  3, ECanadianMultilingual  }, // Canadian-Bilingual
        { 13, EUSInternational       }, // International (ISO)
        { 17, ELatinAmerican         }, // Latin American
        { 27, ESwissFrench           }, // Swiss/French
        { 28, ESwissGerman           }, // Swiss/German
    };

const TInt TFindLayoutId::KCountryMapSize =
    (sizeof (KMapCountryToLayout)) / (sizeof (TCountryMapEntry));

// ----------------------------------------------------------------------
// Map a HID country ID (Nokia SU-8) to a keyboard layout ID:
//
const TFindLayoutId::TCountryMapEntry TFindLayoutId::KMapSu8CountryToLayout[] =
    {
    // HID ID -> Nokia SU-8 layout ID
    //
    // We don't know what language code the SU-8 keyboards will return,
    // so we'll include them all for now:
    //
    { 33, ESu8USEnglish       },  // US
    {  7, ESu8FinnishSwedish  },  // Finnish
    { 26, ESu8FinnishSwedish  },  // Swedish
    {  6, ESu8DanishNorwegian },  // Danish
    { 19, ESu8DanishNorwegian },  // Norwegian
    {  9, ESu8German          }   // German
    };

const TInt TFindLayoutId::KSu8CountryMapSize =
    (sizeof (KMapSu8CountryToLayout)) / (sizeof (TCountryMapEntry));

// ----------------------------------------------------------------------
// Map a TLanguage enum, as returned by User::Language(), to a
// keyboard layout ID:
//
const TFindLayoutId::TLanguageMapEntry TFindLayoutId::KMapLanguageToLayout[] =
    {
        // TLanguage ID           ->  Standard layout ID,  Nokia SU-8 layout ID
        //
        { ELangEnglish,               EUnitedKingdom,      ESu8USEnglish },
        { ELangFrench,                EFrench,             0 },
        { ELangGerman,                EGerman,             ESu8German },
        { ELangSpanish,               ESpanish,            0 },
        { ELangItalian,               EItalian,            0 },
        { ELangSwedish,               EFinnishSwedish,     ESu8FinnishSwedish },
        { ELangDanish,                EDanish,             ESu8DanishNorwegian },
        { ELangNorwegian,             ENorwegian,          ESu8DanishNorwegian },
        { ELangFinnish,               EFinnishSwedish,     ESu8FinnishSwedish },
        { ELangAmerican,              EUnitedStates,       ESu8USEnglish },
        { ELangSwissFrench,           ESwissFrench,        0 },
        { ELangSwissGerman,           ESwissGerman,        0 },
        { ELangPortuguese,            EPortuguese,         0 },
        { ELangIcelandic,             EIcelandic,          0 },
        { ELangDutch,                 EDutch,              0 },
        { ELangBelgianFlemish,        EBelgian,            0 },
        { ELangBelgianFrench,         EBelgian,            0 },
        { ELangInternationalEnglish,  EUSInternational,    ESu8USEnglish },
        { ELangCanadianFrench,        ECanadianFrench,     0 },
        { ELangLatinAmericanSpanish,  ELatinAmerican,      0 },
        { ELangFinlandSwedish,        EFinnishSwedish,     ESu8FinnishSwedish },
        { ELangRussian,				  			ERussian,			   		 ESu8Russian }

        //    	}
    };

const TInt TFindLayoutId::KLanguageMapSize =
    (sizeof (KMapLanguageToLayout)) / (sizeof (TLanguageMapEntry));

// ----------------------------------------------------------------------

TFindLayoutId::TFindLayoutId(TInt aHidCountryId,
                             TInt aVendorId, TInt aProductCode)
    {
    TRACE_INFO( (_L("TFindLayoutId(Country %d, Vendor %d, Product %d)"),
                 aHidCountryId, aVendorId, aProductCode));

    const TInt KNokiaVendorId = 0x5555;
    const TInt KSu8ProductCode = 0x00dd;

    iIsNokiaSu8 = (aVendorId == KNokiaVendorId)
                  && (aProductCode == KSu8ProductCode);

    //Used to identify the NOKIA SU8 PROTOTYPE
    if ((aVendorId == 0x5555) && (aProductCode == 0x5555))
        {
        iIsNokiaSu8 = ETrue;
        }

    iLayout = 0; // 0 = invalid layout ID = "unknown"

    iFoundLayout = EFalse;

    if (aHidCountryId != 0)
        {
        // Use the look-up table to find the most appropriate keyboard
        // layout for this country code:
        //
        TRACE_INFO( (_L("TFindLayoutId(): country %d"),
                     aHidCountryId));
        iLayout = CountryToLayout(aHidCountryId, iIsNokiaSu8);

        if (iLayout != 0)
            {
            iFoundLayout = ETrue;
            }
        }

    if (iLayout == 0)
        {
        // Either no country code was specified, or we couldn't find
        // an appropriate layout listed in the look-up table.
        // Instead, attempt to infer the layout using the current
        // phone language setting:
        //
        TRACE_INFO( (_L("TFindLayoutId(): language %d"),
                     User::Language()));
        iLayout = LanguageToLayout(User::Language(), iIsNokiaSu8);
        }

    if (iLayout == 0)
        {
        iLayout = KDefaultLayoutId;
        TRACE_INFO( (_L("TFindLayoutId(): default layout")));
        }

    TRACE_INFO( (_L("TFindLayoutId(): layout is %d"), iLayout));
    }

// ----------------------------------------------------------------------

TInt TFindLayoutId::CountryToLayout(TInt aHidCountryId, TBool aIsNokiaSu8)
    {
    const TCountryMapEntry* table =
        aIsNokiaSu8 ? KMapSu8CountryToLayout : KMapCountryToLayout;
    const TInt size =
        aIsNokiaSu8 ? KSu8CountryMapSize : KCountryMapSize;

    TInt layout = 0;

    for (TInt i=0; (i<size) && (layout == 0); ++i)
        {
        const TCountryMapEntry& entry = table[i];

        if (entry.iHidCountryId == aHidCountryId)
            {
            layout = entry.iLayoutId;
            }
        }

    return layout;
    }

TInt TFindLayoutId::LanguageToLayout(TLanguage aLanguage, TBool aIsNokiaSu8)
    {
    TInt layout = 0;

    for (TInt i=0; (i<KLanguageMapSize) && (layout == 0); ++i)
        {
        const TLanguageMapEntry& entry = KMapLanguageToLayout[i];

        if (entry.iLanguage == aLanguage)
            {
            layout = aIsNokiaSu8 ? entry.iSu8LayoutId : entry.iLayoutId;
            }
        }

    return layout;
    }

// ----------------------------------------------------------------------