examples/Base/tcharexample/tcharexample.cpp

Go to the documentation of this file.

/*
Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: This example program demonstrates the TChar, TCharF, TCharLC and TCharUC character classes.  
*/




#include "tcharexample.h"

static CConsoleBase* console;

CTCharExample::CTCharExample()
        {
        }

void CTCharExample::ConstructL()
        {
        _LIT(KTitle, "\r\nTChar Example" );
        console = Console::NewL(KTitle, TSize(KConsFullScreen, KConsFullScreen));
        
        _LIT(KWelcome, "\r\nWelcome to the TChar example application");
        console->Printf(KWelcome);
        }

CTCharExample::~CTCharExample()
        {
        delete console;
        }

CTCharExample* CTCharExample::NewL()
        {
        CTCharExample* self = new(ELeave)CTCharExample();
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop(self);
        return self;
        }

void PrintIsXXXFunction(TChar aCharValue)
        {
        if(aCharValue.IsLower())
                {
                _LIT(KLower," The character is lowercase\r\n");
                console->Printf(KLower);
                }
        if(aCharValue.IsUpper())
                {
                _LIT(KUpper," The character is uppercase\r\n");
                console->Printf(KUpper);
                }
        if(aCharValue.IsAlpha())
                {
                _LIT(KAlpha," The character is alphabetic\r\n"); 
                console->Printf(KAlpha);
                }
        if(aCharValue.IsDigit())
                {
                _LIT(KDigit," The character is a digit\r\n");
                console->Printf(KDigit);
                }
        if(aCharValue.IsHexDigit())
                {
                _LIT(KHexDigit," The character is a hexadecimal digit\r\n");
                console->Printf(KHexDigit);
                }
        if(aCharValue.IsSpace())
                {
                _LIT(KSpace," The character is a space\r\n");
                console->Printf(KSpace);
                }
        if(aCharValue.IsPunctuation())
                {
                _LIT(KPunctuation," The character is punctuation\r\n");
                console->Printf(KPunctuation);
                }
        else if(aCharValue.IsPrint())
                {
                _LIT(KPrint," The character is printable\r\n");
                console->Printf(KPrint);
                }
        }
    
void TCharIsXXXFunctions()
        {
        _LIT(KEnterAKey,"\r\nEnter a character to process with the TChar::IsXXX() functions: ");
        console->Printf(KEnterAKey);
        
        TChar charValue = console->Getch();
        _LIT(KPrintChar,"%C\r\n");
        console->Printf(KPrintChar, (TUint)charValue);
        
        // Get and print the character type using the IsXXX() functions.
        PrintIsXXXFunction(charValue);
        }
        
void TCharGetXXXFunctions()
        {
        _LIT(KEnterAKey,"\r\nEnter a character to process with the TChar:GetXXX() functions: ");
        console->Printf(KEnterAKey);
        _LIT(KPrintChar,"%C\r\n");
        TChar charValue = console->Getch();
        
        console->Printf(KPrintChar, (TUint)charValue);

        // Gets the combining class of the character.
        TInt getCombiningClass = charValue.GetCombiningClass();
        _LIT(KCharCombNotClassMsg," The character does not have a combining class\r\n");
        _LIT(KCharCombClassMsg," The character has %d combining classes\r\n");
        if(getCombiningClass == 0)
                console->Printf(KCharCombNotClassMsg);
        else
                console->Printf(KCharCombClassMsg, getCombiningClass);
        
        _LIT(KENeutalWidthMsg," ENeutralWidth: This character type includes 'ambiguous width' as defined in Unicode Technical Report 11: East Asian Width\r\n");
        _LIT(KEHaldWidthMsg," EHalfWidth: This character occupies a single cell\r\n");
        _LIT(KEFullWidthMsg," EFullWidth: This character occupies 2 cells\r\n");
        _LIT(KENarrowMsg," ENarrow: This character is narrow and has explicit full-width counterparts\r\n");
        _LIT(KEWideMsg," EWide: This character is wide\r\n");
        _LIT(KNoWidthMsg," This character has no width defined\r\n");
        // Gets and prints the Chinese, Japanese, Korean (CJK) notional width of the character.
        TChar::TCjkWidth cjkWidth = charValue.GetCjkWidth();
        switch(cjkWidth)
                {
                case TChar::ENeutralWidth:
                        console->Printf(KENeutalWidthMsg);
                        break;
                case TChar::EHalfWidth:
                        console->Printf(KEHaldWidthMsg);
                        break;
                case TChar::EFullWidth:
                        console->Printf(KEFullWidthMsg);
                        break;  
                case TChar::ENarrow:
                        console->Printf(KENarrowMsg);
                        break;
                case TChar::EWide:
                        console->Printf(KEWideMsg);
                        break;
                default:
                        console->Printf(KNoWidthMsg);
                }

        // Prints the different cases if the character is alphabetic.
        if(charValue.IsAlpha())
                {
                // Gets the character after conversion to uppercase (or returns the character itself if no uppercase form exists).
                TUint getCaseValue = charValue.GetUpperCase();
                _LIT(KAferConv2UpMsg," The character after conversion to upper case is %C:\r\n");
                console->Printf(KAferConv2UpMsg, getCaseValue);
        
                // Gets the character after conversion to lowercase (or the character itself if no lowercase form exists).
                getCaseValue = charValue.GetLowerCase();
                _LIT(KAferConv2LowerMsg," The character after conversion to lower case is %C:\r\n"); 
                console->Printf(KAferConv2LowerMsg, getCaseValue);

                // Gets the character after conversion to title-case (or the character itself if no title-case form exists).
                getCaseValue = charValue.GetTitleCase();
                _LIT(KAferConv2TitleMsg," The character after conversion to title case is %C:\r\n");
                console->Printf(KAferConv2TitleMsg, getCaseValue);
                }
        }
        

void TCharInfoFunctions()
        {
        _LIT(KEnterAKey,"\r\nTCharInfo holds all character information\r\nEnter a character to process with TCharInfo: ");
        console->Printf(KEnterAKey);
        
        TChar enteredCharacter = console->Getch();
        _LIT(KPrintChar,"%C\r\n");
        console->Printf(KPrintChar, (TUint)enteredCharacter);
        
        // A structure to hold information about the character.
        TChar::TCharInfo charInfo;
        
        enteredCharacter.GetInfo(charInfo);
        
        // Gets the combining class of the entered character.
        // This determines the relationship between characters in a string
        TInt numberOfCombiningClass = charInfo.iCombiningClass;
        _LIT(KCharCombNotClassMsg," The character does not have a combining class\r\n");
        _LIT(KCharCombClassMsg," The character has %d combining classes\r\n");
        if(numberOfCombiningClass <= 0)
                console->Printf(KCharCombNotClassMsg);
        else
                console->Printf(KCharCombClassMsg, numberOfCombiningClass);

        // Returns True if the character is mirrored.
        // Mirrored characters can change direction according to the directionality of the surrounding characters
        TBool booleanValue = charInfo.iMirrored;
        _LIT(KCharMirroredMsg," The character is mirrored\r\n");
        _LIT(KCharNotMirroredMsg," The character is not mirrored\r\n");
        if(booleanValue)        
                console->Printf(KCharMirroredMsg);
        else
                console->Printf(KCharNotMirroredMsg);
        
        // Gets the numeric value of the character (-1 if none, -2 if a fraction).
        TInt getNumericValue = charInfo.iNumericValue;
        _LIT(KCharNoNumericMsg," The character has no numeric value\r\n");
        _LIT(KCharNumericFractionMsg, " The character is a fraction\r\n");
        if(getNumericValue == -1)       
                console->Printf(KCharNoNumericMsg);
        else if(getNumericValue == -2)  
                console->Printf(KCharNumericFractionMsg);
        
        // Print the different cases if the character is alphabetic.
        if(enteredCharacter.IsAlpha())
                {
                // Gets and prints the title-case form of the character.
                TUint caseValue = charInfo.iTitleCase;
                _LIT(KAferConv2TitleMsg," The character after conversion to title case is %C\r\n");
                console->Printf(KAferConv2TitleMsg, caseValue);
        
                // Gets and prints the upper case form of the character.
                caseValue = charInfo.iUpperCase;
                _LIT(KAferConv2UpMsg," The character after conversion to upper case is %C\r\n");
                console->Printf(KAferConv2UpMsg, caseValue);    
        
                // Gets and prints the lower case form of the character.
                caseValue = charInfo.iLowerCase;
                _LIT(KAferConv2LowerMsg," The character after conversion to lower case is %C\r\n"); 
                console->Printf(KAferConv2LowerMsg, caseValue); 
                } 
        }


void CTCharExample::UseTCharFunctions()
        {
        //Split the TChar functions into logical groups. 
        TInt userChoice = 0;
                do
                {
                _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");
                console->Printf(KLoopMessage);
                
                userChoice = console->Getch();
                
                switch(userChoice) 
                        {
                        case '1':
                                // Use the TChar::IsXXX() functions
                                TCharIsXXXFunctions();
                                break;  
        
                        case '2':
                                // Use the TChar::GetXXX(); functions
                                TCharGetXXXFunctions();
                                break;
                
                        case '3':
                                // Use TCharInfo functions
                                TCharInfoFunctions();   
                                break;
                                        
                        case '0':
                                // Exit
                                break;
                                
                        default:
                                {
                                _LIT(KEnterValidMsg, "\r\nEnter a valid character.\r\n");
                                console->Printf(KEnterValidMsg);
                                }
                        
                        }
                        
                } while (userChoice != '0');
        }

void CTCharExample::UseTCharFFunctions()
        {       
        _LIT(KEnterALowerCaseChar,"\r\nTCharF ignores character differences like case and accent.\r\n Enter a character: ");
        console->Printf(KEnterALowerCaseChar);

        // Gets a character from the console.
        TChar enteredLowerChar = console->Getch();
        _LIT(KPrintChar,"%C\r\n");
        console->Printf(KPrintChar, (TUint)enteredLowerChar);
        
        _LIT(KEnterAnUpperCaseChar," Enter the same character but with a different case or accent.\r\n (use the 'Alt Gr' key to produce an accent): ");
        console->Printf(KEnterAnUpperCaseChar);

        // Gets a character from the console.
        TChar enteredUpperChar = console->Getch();
        console->Printf(KPrintChar, (TUint)enteredUpperChar);
        
        // TCharF folds a specified character so that character differences like case and accents are ignored.
        TCharF lowerCaseValue(enteredLowerChar);
        TCharF upperCaseValue(enteredUpperChar);
        
        // Test both lower and upper case value using TCharF.
        if (lowerCaseValue == upperCaseValue)
                {
                _LIT(KCharEquiMsg," The characters are equivalent\r\n");
                console->Printf(KCharEquiMsg);
                }
        else
                {
                _LIT(KCharNotEquiMsg, " The characters are not equivalent\r\n");
                console->Printf(KCharNotEquiMsg);
                }               
        }

void CTCharExample::UseTCharLCFunctions()
        {
        
        _LIT(KEnterACharForTCharLC,"\r\nTCharLC converts a character to lower case\r\n Enter an upper case character to process with TCharLC: ");
        console->Printf(KEnterACharForTCharLC);

        // Gets a character from the console.
        TChar charValue = console->Getch();
        _LIT(KPrintChar,"%C\r\n");
        console->Printf(KPrintChar, (TUint)charValue);
        
        // Convert and print the character.
        TCharLC convertedCharToLowerCase(charValue);
                
        _LIT(KConvertedTCharLC, "\r\n After conversion the character is: ");
        console->Printf(KConvertedTCharLC);
        console->Printf(KPrintChar,(TUint)convertedCharToLowerCase);
        }
        
void CTCharExample::UseTCharUCFunctions()
        {       
        _LIT(KEnterACharForTCharUC,"\r\nTCharUC converts a character to upper case\r\n Enter a lower case character to process with TCharLC: ");
        console->Printf(KEnterACharForTCharUC);
        _LIT(KPrintChar,"%C\r\n");
        // Gets a character from the console.
        TChar charValue = console->Getch();
        console->Printf(KPrintChar, (TUint)charValue);
        
        // Convert and print the character.
        TCharUC convertedCharUC(charValue);
                
        _LIT(KConvertedTCharUC, "\r\n After conversion the character is: ");
        console->Printf(KConvertedTCharUC);
        console->Printf(KPrintChar,(TUint)convertedCharUC);
        }       
        

void MainL()
        {
        CTCharExample* app = CTCharExample::NewL();
        CleanupStack::PushL(app);

        TInt userChoice = 0;

        do
                {
                _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");
                console->Printf(KLoopMessage);
                
                userChoice = console->Getch();
                
                switch(userChoice) 
                        {
                        case '1':
                                // Use functions belonging to the TChar character class.
                                app->UseTCharFunctions();
                                break;  
        
                        case '2':
                                // Use functions belonging to the TCharF character class.
                                app->UseTCharFFunctions();
                                break;
                
                        case '3':
                                // Use functions belonging to the TCharLC character class.
                                app->UseTCharLCFunctions();     
                                break;
        
                        case '4':
                                // Use functions belonging to the TCharUC character class.
                                app->UseTCharUCFunctions();
                                break;
                        
                        case '0':
                                // Exit
                                break;
                        
                        default:
                                _LIT(KEnterValidMsg, "\r\nEnter a valid character.\r\n");                       
                                console->Printf(KEnterValidMsg);
                        }
                        
                } while (userChoice != '0');
                
                CleanupStack::PopAndDestroy(app);
        } 

extern TInt E32Main()
        {
        __UHEAP_MARK;

        CTrapCleanup* cleanup = CTrapCleanup::New();
        if(cleanup == NULL)
                {
                return KErrNoMemory;
                }
        TRAPD(err, MainL());
        if(err !=KErrNone)
                {
                _LIT(KFailed, "\nFailed to complete");
                User::Panic(KFailed, err);
                }       
        delete cleanup;

        __UHEAP_MARKEND;
        return KErrNone;
        }
  
  
  
  
 
 
 

---