/*

* Copyright (c) 2002 - 2007 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:  test functions in aknutils.h

*

*/

// [INCLUDE FILES]

#include <e32svr.h>

#include <stifparser.h>

#include <stiftestinterface.h>

#include <testsdkuifwutil.rsg>

#include <eikclb.h>

#include <eikfrlbd.h>

#include <e32const.h>

#include <akndialog.h>

#include <aknlists.h>

#include <eikclbd.h>

#include <aknsfld.h>

#include <aknlayout2def.h>

#include <aknlayout2scalabledef.h>

#include <eikmfne.h>

#include <eikseced.h>

#include <aknfontspecification.h>

#include <akniconutils.h>

#include <avkon.mbg>

#include <gulfont.h>

#include "testsdkuifwutil.h"

// CONSTANTS

const TInt KArraySize = 10;

const TInt KBufSize = 64;

const TInt KGeneralWidth = 50;

const TInt KSearchFieldMaxLength = 20;

_LIT( KTextExample, "textexample" );

_LIT( KBitmapFile, "Z:\\resource\\apps\\avkon2.mbm" );

// FORWARD DECLARATIONS

// This class only for test, not any value.

class CScrollBarObserver : public CBase, public MEikScrollBarObserver

    {

public:

    // From MEikScrollBarObserver

    void HandleScrollEventL( CEikScrollBar* /*aScrollBar*/, TEikScrollEvent /*aEventType*/ ){}

    };

// This class only for test, not any value.

class CControlObserver : public CBase, public MCoeControlObserver

    {

public:

    // From MCoeControlObserver

    void HandleControlEventL( CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/ ){}

    };

// ============================ MEMBER FUNCTIONS ===============================

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

// CTestSDKUiFwUtil::TestAknTextUtilsClipToFitL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsClipToFitL( CStifItemParser& aItem )

    {

    TInt num = 0;

    TInt err = aItem.GetNextInt( num );

    if ( err != KErrNone )

        {

        return err;

        }

    const CFont& font = *(iEnv->TitleFont());

    TBool result;

    TBuf<KBufSize> buf( KTextExample );

    switch ( num )

        {

        case ECaseZero:

            {

            result = AknTextUtils::ClipToFit( buf, font, KGeneralWidth);

            break;

            }

        case ECaseOne:

            {

            TInt itemindex = 0;   

            TInt columnnumber = 0;

            CEikColumnListBox* collist = new ( ELeave ) CAknSingleStyleListBox;

            CleanupStack::PushL( collist );

            collist->SetContainerWindowL( *iContainer );

            iContainer->SetComponentControlL( collist );

            TResourceReader reader;

            iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

            collist->ConstructFromResourceL( reader );

            CleanupStack::PopAndDestroy();

            CColumnListBoxData *data = collist->ItemDrawer()->ColumnData();

            data->SetColumnFontL( columnnumber, &font );

            result = AknTextUtils::ClipToFit( buf, AknTextUtils::EClipFromEnd, collist,

                    itemindex, columnnumber );

            CleanupStack::PopAndDestroy( collist );

            break;

            }

        case ECaseTwo:

            {

            TInt itemindex = 0;   

            TInt subcellnumber = 0;

            CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

            CleanupStack::PushL( celllist );

            celllist->SetContainerWindowL( * iContainer );

            TResourceReader reader;

            iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

            celllist->ConstructFromResourceL( reader );

            CleanupStack::PopAndDestroy();

            CFormattedCellListBoxData* formatData = celllist->ItemDrawer()->FormattedCellData();

            formatData->SetSubCellFontL( subcellnumber, &font );

            result = AknTextUtils::ClipToFit( buf, AknTextUtils::EClipFromEnd, celllist,

                    itemindex, subcellnumber );

            CleanupStack::PopAndDestroy( celllist );

            break;

            }

        default:

            {

            return KErrNotSupported;

            }

        }

    STIF_ASSERT_TRUE( result );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAKnTextUtilsWrapToArrayL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToArrayL( CStifItemParser& aItem )

    {

    TInt num = 0;

    TInt err = aItem.GetNextInt( num );

    if ( err != KErrNone )

        {

        return err;

        }

    TBuf<KBufSize> buf( KTextExample );

    CArrayFix<TPtrC>* wraparray = new ( ELeave ) CArrayFixFlat<TPtrC>( KArraySize );

    CleanupStack::PushL( wraparray );

    const CFont& font = *(iEnv->TitleFont());

    switch ( num )

        {

        case ECaseZero:

            {

            AknTextUtils::WrapToArrayL( buf, KGeneralWidth, font, *wraparray );

            break;

            }

        case ECaseOne:

            {

            CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

            CleanupStack::PushL( widtharray );

            AknTextUtils::WrapToArrayL( buf, *widtharray, font, *wraparray );

            CleanupStack::PopAndDestroy( widtharray );

            break;

            }

        default:

            {

            CleanupStack::PopAndDestroy( wraparray );

            return KErrNotSupported;

            }

        }

    CleanupStack::PopAndDestroy( wraparray );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsWrapToArrayAndClipL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToArrayAndClipL( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    CArrayFix<TPtrC>* wraparray = new ( ELeave ) CArrayFixFlat<TPtrC>( KArraySize );

    CleanupStack::PushL( wraparray );

    const CFont& font = *(iEnv->TitleFont());

    CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

    CleanupStack::PushL( widtharray );

    AknTextUtils::WrapToArrayAndClipL( buf, *widtharray, font, *wraparray );

    CleanupStack::PopAndDestroy( widtharray );

    CleanupStack::PopAndDestroy( wraparray );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsChopToArrayAndClipL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsChopToArrayAndClipL( CStifItemParser& aItem )

    {

    TInt num = 0;

    TInt err = aItem.GetNextInt( num );

    if ( err != KErrNone )

        {

        return err;

        }

    TBuf<KBufSize> buf( KTextExample );

    CArrayFix<TPtrC>* wraparray = new ( ELeave ) CArrayFixFlat<TPtrC>( KArraySize );

    CleanupStack::PushL( wraparray );

    const CFont& font = *(iEnv->TitleFont());

    switch ( num )

        {

        case ECaseZero:

            {

            AknTextUtils::ChopToArrayAndClipL( buf, KGeneralWidth, font, *wraparray );

            break;

            }

        case ECaseOne:

            {

            CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

            CleanupStack::PushL( widtharray );

            AknTextUtils::ChopToArrayAndClipL( buf, *widtharray, font, *wraparray );

            CleanupStack::PopAndDestroy( widtharray );

            break;

            }

        default:

            {

            CleanupStack::PopAndDestroy( wraparray );

            return KErrNotSupported;

            }

        }

    CleanupStack::PopAndDestroy( wraparray );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringL( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    TBuf<KBufSize> wrapbuf;

    const CFont& font = *(iEnv->TitleFont());

    CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

    CleanupStack::PushL( widtharray );

    AknTextUtils::WrapToStringL( buf, *widtharray, font, wrapbuf );

    CleanupStack::PopAndDestroy( widtharray );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringAndClipL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringAndClipL( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    TBuf<KBufSize> wrapbuf;

    const CFont& font = *(iEnv->TitleFont());

    CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

    CleanupStack::PushL( widtharray );

    AknTextUtils::WrapToStringAndClipL( buf, *widtharray, font, wrapbuf );

    CleanupStack::PopAndDestroy(widtharray);

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsProcessCharacters

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsProcessCharacters( CStifItemParser& aItem )

    {

    TInt num = 0;

    TInt err = aItem.GetNextInt( num );

    if ( err != KErrNone )

        {

        return err;

        }

    TBuf<KBufSize> buf( KTextExample );

    TBuf<KBufSize> charactor;

    charactor.FillZ();

    charactor.Append( ' ' );

    TChar replacechar( 'a' );

    switch ( num )

        {

        case ECaseZero:

            {

            AknTextUtils::StripCharacters( buf, charactor );

            break;

            }

        case ECaseOne:

            {

            AknTextUtils::ReplaceCharacters( buf, charactor, replacechar );

            break;

            }

        case ECaseTwo:

            {

            AknTextUtils::PackWhiteSpaces( buf, charactor );

            break;

            }

        default:

            {

            return KErrNotSupported;

            }

        }

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsLanguageSpecificNumberConversion

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsLanguageSpecificNumberConversion( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    AknTextUtils::LanguageSpecificNumberConversion( buf );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsConvertDigitsTo

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsConvertDigitsTo( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    AknTextUtils::ConvertDigitsTo( buf, EDigitTypeAllTypes );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsCurrentScriptDirectionality

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsCurrentScriptDirectionality( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    AknTextUtils::CurrentScriptDirectionality();

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsNumericEditorDigitType

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsNumericEditorDigitType( CStifItemParser& /*aItem*/ )

    {

    AknTextUtils::NumericEditorDigitType();

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsDisplayTextLanguageSpecificNumberConversion

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsDisplayTextLanguageSpecificNumberConversion( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    AknTextUtils::DisplayTextLanguageSpecificNumberConversion( buf );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsTextEditorDigitType

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsTextEditorDigitType( CStifItemParser& /*aItem*/ )

    {

    AknTextUtils::TextEditorDigitType();

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsDigitModeQuery

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsDigitModeQuery( CStifItemParser& /*aItem*/ )

    {

    AknTextUtils::DigitModeQuery( AknTextUtils::EDigitModeNumberEditor );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsConvertFileNameL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsConvertFileNameL( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    AknTextUtils::ConvertFileNameL( buf );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsLoadTextL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsLoadTextL( CStifItemParser& /*aItem*/ )

    {

    TBuf<64> buf;

    AknTextUtils::LoadScalableText( *(CCoeEnv::Static()), 

        R_AKNTEXTUTILS_BUFZERO, buf );

    AknTextUtils::LoadScalableTextL( *(CCoeEnv::Static()), R_AKNTEXTUTILS_BUF );

    AknTextUtils::LoadScalableTextLC( *(CCoeEnv::Static()), R_AKNTEXTUTILS_BUF );

    CleanupStack::PopAndDestroy();

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsClipAccordingScreenOrientationLCL

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsClipAccordingScreenOrientationLCL( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    HBufC* hbuf = HBufC::NewL( KBufSize );

    *hbuf = buf;    

    AknTextUtils::ClipAccordingScreenOrientationLC( *(CCoeEnv::Static()), hbuf );

    CleanupStack::PopAndDestroy();

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknTextUtilsChooseScalableText

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

//

TInt CTestSDKUiFwUtil::TestAknTextUtilsChooseScalableText( CStifItemParser& /*aItem*/ )

    {

    TBuf<KBufSize> buf( KTextExample );

    const CFont& font = *(iEnv->TitleFont());

    AknTextUtils::ChooseScalableText( buf, font, KGeneralWidth );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknSelectServHandleSelectionListProcessCommandL

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

//

TInt CTestSDKUiFwUtil::TestAknSelectServHandleSelectionListProcessCommandL( CStifItemParser& /*aItem*/ )

    {

    CEikListBox* list = new ( ELeave ) CEikListBox;

    CleanupStack::PushL( list );

    AknSelectionService::HandleSelectionListProcessCommandL( 0, list );

    CleanupStack::PopAndDestroy( list );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknSelectServHandleMultiselectionListProcessCommandL

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

//

TInt CTestSDKUiFwUtil::TestAknSelectServHandleMultiselectionListProcessCommandL( CStifItemParser& /*aItem*/ )

    {

    CEikListBox* list = new ( ELeave ) CEikListBox;

    CleanupStack::PushL( list );

    AknSelectionService::HandleMultiselectionListProcessCommandL( 0, list );

    CleanupStack::PopAndDestroy( list );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListProcessCommandL

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

//

TInt CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListProcessCommandL( CStifItemParser& /*aItem*/ )

    {

    CEikListBox* list = new ( ELeave ) CEikListBox;

    CleanupStack::PushL( list );

    AknSelectionService::HandleMarkableListProcessCommandL( 0, list );

    CleanupStack::PopAndDestroy( list );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknSelectServHandleMenuListOfferKeyEventL

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

//

TInt CTestSDKUiFwUtil::TestAknSelectServHandleMenuListOfferKeyEventL( CStifItemParser& /*aItem*/ )

    {

    CEikListBox* list = new ( ELeave ) CAknSingleStyleListBox;

    CleanupStack::PushL( list );

    list->SetContainerWindowL( *iContainer );

    iContainer->SetComponentControlL( list );

    TResourceReader reader;

    iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

    list->ConstructFromResourceL( reader );

    CleanupStack::PopAndDestroy();

    TKeyEvent keyevent = { EKeyLeftShift, 0, 0, 0 };

    AknSelectionService::HandleMenuListOfferKeyEventL( keyevent, EEventKey, list );

    CleanupStack::PopAndDestroy( list );

    return KErrNone;

    }

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

// CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListDynInitMenuPaneL

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

//

TInt CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListDynInitMenuPaneL( CStifItemParser& /*aItem*/ )