TB10.1 Example Applications: examples/Base/tcharexample/tcharexample.cpp Source File

00001 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+00002 // All rights reserved.
+00003 // This component and the accompanying materials are made available
+00004 // under the terms of "Eclipse Public License v1.0"
+00005 // which accompanies this distribution, and is available
+00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00007 //
+00008 // Initial Contributors:
+00009 // Nokia Corporation - initial contribution.
+00010 //
+00011 // Contributors:
+00012 //
+00013 // Description:
+00014 // This example program demonstrates the TChar, TCharF, TCharLC and TCharUC character classes.
+00015 //
+00016 
+00017 
+00018 
+00023 #include "tcharexample.h"
+00024 
+00025 static CConsoleBase* console;
+00026 
+00030 CTCharExample::CTCharExample()
+00031         {
+00032         }
+00033 
+00034 void CTCharExample::ConstructL()
+00035         {
+00036         _LIT(KTitle, "\r\nTChar Example" );
+00037         console = Console::NewL(KTitle, TSize(KConsFullScreen, KConsFullScreen));
+00038         
+00039         _LIT(KWelcome, "\r\nWelcome to the TChar example application");
+00040         console->Printf(KWelcome);
+00041         }
+00042 
+00046 CTCharExample::~CTCharExample()
+00047         {
+00048         delete console;
+00049         }
+00050 
+00055 CTCharExample* CTCharExample::NewL()
+00056         {
+00057         CTCharExample* self = new(ELeave)CTCharExample();
+00058         CleanupStack::PushL(self);
+00059         self->ConstructL();
+00060         CleanupStack::Pop(self);
+00061         return self;
+00062         }
+00063 
+00068 void PrintIsXXXFunction(TChar aCharValue)
+00069         {
+00070         if(aCharValue.IsLower())
+00071                 {
+00072                 _LIT(KLower," The character is lowercase\r\n");
+00073                 console->Printf(KLower);
+00074                 }
+00075         if(aCharValue.IsUpper())
+00076                 {
+00077                 _LIT(KUpper," The character is uppercase\r\n");
+00078                 console->Printf(KUpper);
+00079                 }
+00080         if(aCharValue.IsAlpha())
+00081                 {
+00082                 _LIT(KAlpha," The character is alphabetic\r\n"); 
+00083                 console->Printf(KAlpha);
+00084                 }
+00085         if(aCharValue.IsDigit())
+00086                 {
+00087                 _LIT(KDigit," The character is a digit\r\n");
+00088                 console->Printf(KDigit);
+00089                 }
+00090         if(aCharValue.IsHexDigit())
+00091                 {
+00092                 _LIT(KHexDigit," The character is a hexadecimal digit\r\n");
+00093                 console->Printf(KHexDigit);
+00094                 }
+00095         if(aCharValue.IsSpace())
+00096                 {
+00097                 _LIT(KSpace," The character is a space\r\n");
+00098                 console->Printf(KSpace);
+00099                 }
+00100         if(aCharValue.IsPunctuation())
+00101                 {
+00102                 _LIT(KPunctuation," The character is punctuation\r\n");
+00103                 console->Printf(KPunctuation);
+00104                 }
+00105         else if(aCharValue.IsPrint())
+00106                 {
+00107                 _LIT(KPrint," The character is printable\r\n");
+00108                 console->Printf(KPrint);
+00109                 }
+00110         }
+00111     
+00115 void TCharIsXXXFunctions()
+00116         {
+00117         _LIT(KEnterAKey,"\r\nEnter a character to process with the TChar::IsXXX() functions: ");
+00118         console->Printf(KEnterAKey);
+00119         
+00120         TChar charValue = console->Getch();
+00121         _LIT(KPrintChar,"%C\r\n");
+00122         console->Printf(KPrintChar, (TUint)charValue);
+00123         
+00124         // Get and print the character type using the IsXXX() functions.
+00125         PrintIsXXXFunction(charValue);
+00126         }
+00127         
+00131 void TCharGetXXXFunctions()
+00132         {
+00133         _LIT(KEnterAKey,"\r\nEnter a character to process with the TChar:GetXXX() functions: ");
+00134         console->Printf(KEnterAKey);
+00135         _LIT(KPrintChar,"%C\r\n");
+00136         TChar charValue = console->Getch();
+00137         
+00138         console->Printf(KPrintChar, (TUint)charValue);
+00139 
+00140         // Gets the combining class of the character.
+00141         TInt getCombiningClass = charValue.GetCombiningClass();
+00142         _LIT(KCharCombNotClassMsg," The character does not have a combining class\r\n");
+00143         _LIT(KCharCombClassMsg," The character has %d combining classes\r\n");
+00144         if(getCombiningClass == 0)
+00145                 console->Printf(KCharCombNotClassMsg);
+00146         else
+00147                 console->Printf(KCharCombClassMsg, getCombiningClass);
+00148         
+00149         _LIT(KENeutalWidthMsg," ENeutralWidth: This character type includes 'ambiguous width' as defined in Unicode Technical Report 11: East Asian Width\r\n");
+00150         _LIT(KEHaldWidthMsg," EHalfWidth: This character occupies a single cell\r\n");
+00151         _LIT(KEFullWidthMsg," EFullWidth: This character occupies 2 cells\r\n");
+00152         _LIT(KENarrowMsg," ENarrow: This character is narrow and has explicit full-width counterparts\r\n");
+00153         _LIT(KEWideMsg," EWide: This character is wide\r\n");
+00154         _LIT(KNoWidthMsg," This character has no width defined\r\n");
+00155         // Gets and prints the Chinese, Japanese, Korean (CJK) notional width of the character.
+00156         TChar::TCjkWidth cjkWidth = charValue.GetCjkWidth();
+00157         switch(cjkWidth)
+00158                 {
+00159                 case TChar::ENeutralWidth:
+00160                         console->Printf(KENeutalWidthMsg);
+00161                         break;
+00162                 case TChar::EHalfWidth:
+00163                         console->Printf(KEHaldWidthMsg);
+00164                         break;
+00165                 case TChar::EFullWidth:
+00166                         console->Printf(KEFullWidthMsg);
+00167                         break;  
+00168                 case TChar::ENarrow:
+00169                         console->Printf(KENarrowMsg);
+00170                         break;
+00171                 case TChar::EWide:
+00172                         console->Printf(KEWideMsg);
+00173                         break;
+00174                 default:
+00175                         console->Printf(KNoWidthMsg);
+00176                 }
+00177 
+00178         // Prints the different cases if the character is alphabetic.
+00179         if(charValue.IsAlpha())
+00180                 {
+00181                 // Gets the character after conversion to uppercase (or returns the character itself if no uppercase form exists).
+00182                 TUint getCaseValue = charValue.GetUpperCase();
+00183                 _LIT(KAferConv2UpMsg," The character after conversion to upper case is %C:\r\n");
+00184                 console->Printf(KAferConv2UpMsg, getCaseValue);
+00185         
+00186                 // Gets the character after conversion to lowercase (or the character itself if no lowercase form exists).
+00187                 getCaseValue = charValue.GetLowerCase();
+00188                 _LIT(KAferConv2LowerMsg," The character after conversion to lower case is %C:\r\n"); 
+00189                 console->Printf(KAferConv2LowerMsg, getCaseValue);
+00190 
+00191                 // Gets the character after conversion to title-case (or the character itself if no title-case form exists).
+00192                 getCaseValue = charValue.GetTitleCase();
+00193                 _LIT(KAferConv2TitleMsg," The character after conversion to title case is %C:\r\n");
+00194                 console->Printf(KAferConv2TitleMsg, getCaseValue);
+00195                 }
+00196         }
+00197         
+00198 
+00202 void TCharInfoFunctions()
+00203         {
+00204         _LIT(KEnterAKey,"\r\nTCharInfo holds all character information\r\nEnter a character to process with TCharInfo: ");
+00205         console->Printf(KEnterAKey);
+00206         
+00207         TChar enteredCharacter = console->Getch();
+00208         _LIT(KPrintChar,"%C\r\n");
+00209         console->Printf(KPrintChar, (TUint)enteredCharacter);
+00210         
+00211         // A structure to hold information about the character.
+00212         TChar::TCharInfo charInfo;
+00213         
+00214         enteredCharacter.GetInfo(charInfo);
+00215         
+00216         // Gets the combining class of the entered character.
+00217         // This determines the relationship between characters in a string
+00218         TInt numberOfCombiningClass = charInfo.iCombiningClass;
+00219         _LIT(KCharCombNotClassMsg," The character does not have a combining class\r\n");
+00220         _LIT(KCharCombClassMsg," The character has %d combining classes\r\n");
+00221         if(numberOfCombiningClass <= 0)
+00222                 console->Printf(KCharCombNotClassMsg);
+00223         else
+00224                 console->Printf(KCharCombClassMsg, numberOfCombiningClass);
+00225 
+00226         // Returns True if the character is mirrored.
+00227         // Mirrored characters can change direction according to the directionality of the surrounding characters
+00228         TBool booleanValue = charInfo.iMirrored;
+00229         _LIT(KCharMirroredMsg," The character is mirrored\r\n");
+00230         _LIT(KCharNotMirroredMsg," The character is not mirrored\r\n");
+00231         if(booleanValue)        
+00232                 console->Printf(KCharMirroredMsg);
+00233         else
+00234                 console->Printf(KCharNotMirroredMsg);
+00235         
+00236         // Gets the numeric value of the character (-1 if none, -2 if a fraction).
+00237         TInt getNumericValue = charInfo.iNumericValue;
+00238         _LIT(KCharNoNumericMsg," The character has no numeric value\r\n");
+00239         _LIT(KCharNumericFractionMsg, " The character is a fraction\r\n");
+00240         if(getNumericValue == -1)       
+00241                 console->Printf(KCharNoNumericMsg);
+00242         else if(getNumericValue == -2)  
+00243                 console->Printf(KCharNumericFractionMsg);
+00244         
+00245         // Print the different cases if the character is alphabetic.
+00246         if(enteredCharacter.IsAlpha())
+00247                 {
+00248                 // Gets and prints the title-case form of the character.
+00249                 TUint caseValue = charInfo.iTitleCase;
+00250                 _LIT(KAferConv2TitleMsg," The character after conversion to title case is %C\r\n");
+00251                 console->Printf(KAferConv2TitleMsg, caseValue);
+00252         
+00253                 // Gets and prints the upper case form of the character.
+00254                 caseValue = charInfo.iUpperCase;
+00255                 _LIT(KAferConv2UpMsg," The character after conversion to upper case is %C\r\n");
+00256                 console->Printf(KAferConv2UpMsg, caseValue);    
+00257         
+00258                 // Gets and prints the lower case form of the character.
+00259                 caseValue = charInfo.iLowerCase;
+00260                 _LIT(KAferConv2LowerMsg," The character after conversion to lower case is %C\r\n"); 
+00261                 console->Printf(KAferConv2LowerMsg, caseValue); 
+00262                 } 
+00263         }
+00264 
+00265 
+00269 void CTCharExample::UseTCharFunctions()
+00270         {
+00271         //Split the TChar functions into logical groups. 
+00272         TInt userChoice = 0;
+00273                 do
+00274                 {
+00275                 _LIT(KLoopMessage, "\r\nTChar function menu.\r\n 1 to use the IsXXX() functions,\r\n 2 to use the Getxxx() functions,\r\n 3 to use the TCharInfo class,\r\n or 0 to return to the main menu.\r\n");
+00276                 console->Printf(KLoopMessage);
+00277                 
+00278                 userChoice = console->Getch();
+00279                 
+00280                 switch(userChoice) 
+00281                         {
+00282                         case '1':
+00283                                 // Use the TChar::IsXXX() functions
+00284                                 TCharIsXXXFunctions();
+00285                                 break;  
+00286         
+00287                         case '2':
+00288                                 // Use the TChar::GetXXX(); functions
+00289                                 TCharGetXXXFunctions();
+00290                                 break;
+00291                 
+00292                         case '3':
+00293                                 // Use TCharInfo functions
+00294                                 TCharInfoFunctions();   
+00295                                 break;
+00296                                         
+00297                         case '0':
+00298                                 // Exit
+00299                                 break;
+00300                                 
+00301                         default:
+00302                                 {
+00303                                 _LIT(KEnterValidMsg, "\r\nEnter a valid character.\r\n");
+00304                                 console->Printf(KEnterValidMsg);
+00305                                 }
+00306                         
+00307                         }
+00308                         
+00309                 } while (userChoice != '0');
+00310         }
+00311 
+00315 void CTCharExample::UseTCharFFunctions()
+00316         {       
+00317         _LIT(KEnterALowerCaseChar,"\r\nTCharF ignores character differences like case and accent.\r\n Enter a character: ");
+00318         console->Printf(KEnterALowerCaseChar);
+00319 
+00320         // Gets a character from the console.
+00321         TChar enteredLowerChar = console->Getch();
+00322         _LIT(KPrintChar,"%C\r\n");
+00323         console->Printf(KPrintChar, (TUint)enteredLowerChar);
+00324         
+00325         _LIT(KEnterAnUpperCaseChar," Enter the same character but with a different case or accent.\r\n (use the 'Alt Gr' key to produce an accent): ");
+00326         console->Printf(KEnterAnUpperCaseChar);
+00327 
+00328         // Gets a character from the console.
+00329         TChar enteredUpperChar = console->Getch();
+00330         console->Printf(KPrintChar, (TUint)enteredUpperChar);
+00331         
+00332         // TCharF folds a specified character so that character differences like case and accents are ignored.
+00333         TCharF lowerCaseValue(enteredLowerChar);
+00334         TCharF upperCaseValue(enteredUpperChar);
+00335         
+00336         // Test both lower and upper case value using TCharF.
+00337         if (lowerCaseValue == upperCaseValue)
+00338                 {
+00339                 _LIT(KCharEquiMsg," The characters are equivalent\r\n");
+00340                 console->Printf(KCharEquiMsg);
+00341                 }
+00342         else
+00343                 {
+00344                 _LIT(KCharNotEquiMsg, " The characters are not equivalent\r\n");
+00345                 console->Printf(KCharNotEquiMsg);
+00346                 }               
+00347         }
+00348 
+00352 void CTCharExample::UseTCharLCFunctions()
+00353         {
+00354         
+00355         _LIT(KEnterACharForTCharLC,"\r\nTCharLC converts a character to lower case\r\n Enter an upper case character to process with TCharLC: ");
+00356         console->Printf(KEnterACharForTCharLC);
+00357 
+00358         // Gets a character from the console.
+00359         TChar charValue = console->Getch();
+00360         _LIT(KPrintChar,"%C\r\n");
+00361         console->Printf(KPrintChar, (TUint)charValue);
+00362         
+00363         // Convert and print the character.
+00364         TCharLC convertedCharToLowerCase(charValue);
+00365                 
+00366         _LIT(KConvertedTCharLC, "\r\n After conversion the character is: ");
+00367         console->Printf(KConvertedTCharLC);
+00368         console->Printf(KPrintChar,(TUint)convertedCharToLowerCase);
+00369         }
+00370         
+00374 void CTCharExample::UseTCharUCFunctions()
+00375         {       
+00376         _LIT(KEnterACharForTCharUC,"\r\nTCharUC converts a character to upper case\r\n Enter a lower case character to process with TCharLC: ");
+00377         console->Printf(KEnterACharForTCharUC);
+00378         _LIT(KPrintChar,"%C\r\n");
+00379         // Gets a character from the console.
+00380         TChar charValue = console->Getch();
+00381         console->Printf(KPrintChar, (TUint)charValue);
+00382         
+00383         // Convert and print the character.
+00384         TCharUC convertedCharUC(charValue);
+00385                 
+00386         _LIT(KConvertedTCharUC, "\r\n After conversion the character is: ");
+00387         console->Printf(KConvertedTCharUC);
+00388         console->Printf(KPrintChar,(TUint)convertedCharUC);
+00389         }       
+00390         
+00391 
+00392 void MainL()
+00393         {
+00394         CTCharExample* app = CTCharExample::NewL();
+00395         CleanupStack::PushL(app);
+00396 
+00397         TInt userChoice = 0;
+00398 
+00399         do
+00400                 {
+00401                 _LIT(KLoopMessage, "\r\nPress 1 to use the TChar functions,\r\n 2 to use the TCharF function,\r\n 3 to use the TCharLC function,\r\n 4 to use the TCharUC function,\r\n or 0 to exit the application.\r\n");
+00402                 console->Printf(KLoopMessage);
+00403                 
+00404                 userChoice = console->Getch();
+00405                 
+00406                 switch(userChoice) 
+00407                         {
+00408                         case '1':
+00409                                 // Use functions belonging to the TChar character class.
+00410                                 app->UseTCharFunctions();
+00411                                 break;  
+00412         
+00413                         case '2':
+00414                                 // Use functions belonging to the TCharF character class.
+00415                                 app->UseTCharFFunctions();
+00416                                 break;
+00417                 
+00418                         case '3':
+00419                                 // Use functions belonging to the TCharLC character class.
+00420                                 app->UseTCharLCFunctions();     
+00421                                 break;
+00422         
+00423                         case '4':
+00424                                 // Use functions belonging to the TCharUC character class.
+00425                                 app->UseTCharUCFunctions();
+00426                                 break;
+00427                         
+00428                         case '0':
+00429                                 // Exit
+00430                                 break;
+00431                         
+00432                         default:
+00433                                 _LIT(KEnterValidMsg, "\r\nEnter a valid character.\r\n");                       
+00434                                 console->Printf(KEnterValidMsg);
+00435                         }
+00436                         
+00437                 } while (userChoice != '0');
+00438                 
+00439                 CleanupStack::PopAndDestroy(app);
+00440         } 
+00441 
+00442 extern TInt E32Main()
+00443         {
+00444         __UHEAP_MARK;
+00445 
+00446         CTrapCleanup* cleanup = CTrapCleanup::New();
+00447         if(cleanup == NULL)
+00448                 {
+00449                 return KErrNoMemory;
+00450                 }
+00451         TRAPD(err, MainL());
+00452         if(err !=KErrNone)
+00453                 {
+00454                 _LIT(KFailed, "\nFailed to complete");
+00455                 User::Panic(KFailed, err);
+00456                 }       
+00457         delete cleanup;
+00458 
+00459         __UHEAP_MARKEND;
+00460         return KErrNone;
+00461         }
+00462   
+00463   
+00464   
+00465   
+00466  
+00467  
+00468  
+