1 /*

     2 * Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  

    15  *

    16 */

    17 

    18 

    19 #include "layoututils.h"

    20 

    21 TInt CLayoutUtils::IndexFromStandardLayout(THidKeyboardLayoutId aLayoutId)

    22     {

    23     TInt returnValue = 0;

    24     // Map from layout code to item index position.

    25     switch (aLayoutId)

    26         {

    27         case EUnitedKingdom:

    28             returnValue = 0;

    29             break;

    30         case EUnitedStates:

    31             returnValue = 1;

    32             break;

    33         case EUSInternational:

    34             returnValue = 2;

    35             break;

    36         case EBelgian:

    37             returnValue = 3;

    38             break;

    39         case EDanish:

    40             returnValue = 4;

    41             break;

    42         case EDutch:

    43             returnValue = 5;

    44             break;

    45         case EFinnishSwedish:

    46             returnValue = 6;

    47             break;

    48         case EFrench:

    49             returnValue = 7;

    50             break;

    51         case EGerman:

    52             returnValue = 8;

    53             break;

    54         case EItalian:

    55             returnValue = 9;

    56             break;

    57         case ENorwegian:

    58             returnValue = 10;

    59             break;

    60         case EPortuguese:

    61             returnValue = 11;

    62             break;

    63         case ESpanish:

    64             returnValue = 12;

    65             break;

    66         case EUnitedStatesDvorak:

    67             returnValue = 13;

    68             break;

    69         default:

    70             break;

    71         }

    72 

    73     return returnValue;

    74     }

    75 

    76 TInt CLayoutUtils::IndexFromNokiaLayout(THidKeyboardLayoutId aLayoutId)

    77     {

    78     TInt returnValue = 0;

    79     // Map from layout code to item index position.

    80     switch (aLayoutId)

    81         {

    82         case ESu8USEnglish:

    83             returnValue = 0;

    84             break;

    85         case ESu8FinnishSwedish:

    86             returnValue = 1;

    87             break;

    88         case ESu8German:

    89             returnValue = 2;

    90             break;

    91         case ESu8DanishNorwegian:

    92             returnValue = 3;

    93             break;

    94         case ESu8Russian:

    95             returnValue = 4;

    96             break;

    97         default:

    98             break;

    99         }

   100 

   101     return returnValue;

   102     }

   103 

   104 THidKeyboardLayoutId CLayoutUtils::StandardLayoutFromIndex(TInt aIndex)

   105     {

   106     THidKeyboardLayoutId layoutCode = EUnitedKingdom;

   107 

   108     // Map it back from item index position to layout code.

   109     switch (aIndex)

   110         {

   111         case 0:

   112             layoutCode = EUnitedKingdom;

   113             break;

   114         case 1:

   115             layoutCode = EUnitedStates;

   116             break;

   117         case 2:

   118             layoutCode = EUSInternational;

   119             break;

   120         case 3:

   121             layoutCode = EBelgian;

   122             break;

   123         case 4:

   124             layoutCode = EDanish;

   125             break;

   126         case 5:

   127             layoutCode = EDutch;

   128             break;

   129         case 6:

   130             layoutCode = EFinnishSwedish;

   131             break;

   132         case 7:

   133             layoutCode = EFrench;

   134             break;

   135         case 8:

   136             layoutCode = EGerman;

   137             break;

   138         case 9:

   139             layoutCode = EItalian;

   140             break;

   141         case 10:

   142             layoutCode = ENorwegian;

   143             break;

   144         case 11:

   145             layoutCode = EPortuguese;

   146             break;

   147         case 12:

   148             layoutCode = ESpanish;

   149             break;

   150         case 13:

   151             layoutCode = EUnitedStatesDvorak;

   152             break;

   153         default:

   154             break;

   155         }

   156 

   157     return layoutCode;

   158     }

   159 

   160 THidKeyboardLayoutId CLayoutUtils::NokiaLayoutFromIndex(TInt aIndex)

   161     {

   162     THidKeyboardLayoutId layoutCode = ESu8USEnglish;

   163 

   164     // Map it back from item index position to layout code.

   165     switch (aIndex)

   166         {

   167         case 0:

   168             layoutCode = ESu8USEnglish;

   169             break;

   170         case 1:

   171             layoutCode = ESu8FinnishSwedish;

   172             break;

   173         case 2:

   174             layoutCode = ESu8German;

   175             break;

   176         case 3:

   177             layoutCode = ESu8DanishNorwegian;

   178             break;

   179         case 4:

   180             layoutCode = ESu8Russian;

   181             break;

   182         default:

   183             break;

   184         }

   185 

   186     return layoutCode;

   187     }

   188 

   189 void CLayoutUtils::ValidateStandardLayout(THidKeyboardLayoutId& aLayoutId)

   190     {

   191     // If the layout isn't in the range of standard layouts, set it to

   192     // UK

   193     if (!((aLayoutId >= EUnitedKingdom) && (aLayoutId <= EUnitedStatesDvorak)))

   194         {

   195         aLayoutId = EUnitedKingdom;

   196         }

   197     }

   198 

   199 void CLayoutUtils::ValidateNokiaSU8Layout(THidKeyboardLayoutId& aLayoutId)

   200     {

   201     // If the layout isn't in the range of Nokia Su8 layouts, set it to

   202     // English Su8

   203     if (!((aLayoutId >= ESu8USEnglish) && (aLayoutId <= ESu8Russian)))

   204         {

   205         aLayoutId = ESu8USEnglish;

   206         }

   207     }

   208 

   209 TInt CLayoutUtils::LayoutConfirmationStringL(THidKeyboardLayoutId aLayoutCode)

   210     {

   211 

   212     TInt result = 0;

   213     (void) aLayoutCode;

   214     // Only Standard layouts are supported.

   215     // Identify the layout confirmation string based on the layout code.

   216     /*

   217      switch ( aLayoutCode )

   218      {     

   219      case ESu8USEnglish:

   220      result = R_STRING_LAYOUT_ENGLISH;

   221      break;

   222      case ESu8German:

   223      result = R_STRING_LAYOUT_GERMAN;

   224      break;

   225      case ESu8FinnishSwedish:

   226      result = R_STRING_LAYOUT_FINNISH_SWEDISH;

   227      break;

   228      case ESu8DanishNorwegian:

   229      result = R_STRING_LAYOUT_NORWEGIAN_DANISH;

   230      break;

   231      case ESu8Russian:

   232      result = R_STRING_LAYOUT_RUSSIAN;

   233      break;            

   234      case EUnitedKingdom:

   235      result = R_STRING_LAYOUT_UK;

   236      break;

   237      case EUnitedStates:

   238      result = R_STRING_LAYOUT_US;

   239      break;

   240      case EUSInternational:

   241      result = R_STRING_LAYOUT_US_INT;

   242      break;

   243      case EBelgian:

   244      result = R_STRING_LAYOUT_BELGIAN;

   245      break;

   246      case EDanish:

   247      result = R_STRING_LAYOUT_DANISH;

   248      break;

   249      case EDutch:

   250      result = R_STRING_LAYOUT_DUTCH;

   251      break;

   252      case EFinnishSwedish:

   253      result = R_STRING_LAYOUT_FINNISH_SWEDISH;

   254      break;

   255      case EFrench:

   256      result = R_STRING_LAYOUT_FRENCH;

   257      break;

   258      case EGerman:

   259      result = R_STRING_LAYOUT_GERMAN;

   260      break;

   261      case EItalian:

   262      result = R_STRING_LAYOUT_ITALIAN;

   263      break;

   264      case ENorwegian:

   265      result = R_STRING_LAYOUT_NORWEGIAN;

   266      break;

   267      case EPortuguese:

   268      result = R_STRING_LAYOUT_PORTUGUESE;

   269      break;

   270      case ESpanish:

   271      result = R_STRING_LAYOUT_SPANISH;

   272      break;

   273      case EUnitedStatesDvorak:

   274      result = R_STRING_LAYOUT_US_DVORAK;

   275      break;    

   276      default:

   277      User::Leave(KErrNotSupported);

   278      break;

   279      }

   280      */

   281     return result;

   282     }

   283 

   284 TBool CLayoutUtils::SameCategory(THidKeyboardLayoutId aInitialLayoutCode,

   285         THidKeyboardLayoutId aLayoutId)

   286     {

   287     // If the layout isn't in the range of Nokia Su8 layouts, set it to

   288     // English Su8

   289     TBool ret = EFalse;

   290     if (((aLayoutId >= ESu8USEnglish) && (aLayoutId <= ESu8Russian))

   291             && ((aInitialLayoutCode >= ESu8USEnglish) && (aInitialLayoutCode

   292                     <= ESu8Russian)))

   293         {

   294         ret = ETrue;

   295         }

   296 

   297     if (((aLayoutId >= EUnitedKingdom) && (aLayoutId <= EUnitedStatesDvorak))

   298             && ((aInitialLayoutCode >= EUnitedKingdom) && (aInitialLayoutCode

   299                     <= EUnitedStatesDvorak)))

   300         {

   301         ret = ETrue;

   302         }

   303     return ret;

   304     }

   305