/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  CBrCtlApiTestContainer from BrCtlBCTestContainer.h

*

*/

// INCLUDE FILES

#include "BrCtlApiTestContainer.h"

#include <eiklabel.h>  // for example label control

#include <aknview.h>

#include <AknGlobalConfirmationQuery.h>

#include <BrCtlInterface.h>

#include <CHARCONV.H>

#include "BrCtlApiTestObserver.h"

#include <e32std.h>

_LIT8( KContentDataType, "text/html" );

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

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

// CBrCtlApiTestContainer::ConstructL(const TRect& aRect)

// EPOC two phased constructor

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

//

void CBrCtlApiTestContainer::ConstructL(const TRect& aRect)

    {

    iBrCtlApiTestObserver = CBrCtlApiTestObserver::NewL();

    iBrCtlApiTestStateChangeObserver = CBrCtlApiTestStateChangeObserver::NewL( this );

    iBrCtlDialogs = CBrowserDialogsProviderProxy::NewL();

    iCommandBase = TBrCtlDefs::ECommandIdBase;

    CreateWindowL();

    SetRect(aRect);

    ActivateL();

    }

// Destructor

CBrCtlApiTestContainer::~CBrCtlApiTestContainer()

    {

    if (iBrCtlInterface)

        {

        iBrCtlInterface->RemoveLoadEventObserver(iBrCtlApiTestObserver);

        iBrCtlInterface->RemoveStateChangeObserver(iBrCtlApiTestStateChangeObserver);

        delete iBrCtlInterface;

        }

    delete iBrCtlApiTestStateChangeObserver;

    delete iBrCtlApiTestObserver;

    delete iBrCtlDialogs;

    }

void CBrCtlApiTestContainer::CancelLoad()

    {

    iCancelInitDataLoad = ETrue;

    }

TInt CBrCtlApiTestContainer::LoadPageL()

    {

    if(iBrCtlInterface)

        {

        iBrCtlInterface->LoadUrlL(KUrlLoadTestHtml2);

        }

     return KErrNone;

     }

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

// CBrCtlApiTestContainer::SizeChanged()

// Called by framework when the view size is changed

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

//

void CBrCtlApiTestContainer::SizeChanged()

    {

    if (iBrCtlInterface)

        {

        iBrCtlInterface->SetRect(Rect());

        }

    }

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

// CBrCtlApiTestContainer::CountComponentControls() const

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

//

TInt CBrCtlApiTestContainer::CountComponentControls() const

    {

    if (iBrCtlInterface)

        return 1;

    return 0;

    }

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

// CBrCtlApiTestContainer::ComponentControl(TInt aIndex) const

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

//

CCoeControl* CBrCtlApiTestContainer::ComponentControl(TInt aIndex) const

    {

    switch ( aIndex )

        {

        case 0:

            return iBrCtlInterface; // Could be NULL

        default:

            return NULL;

        }

    }

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

// CBrCtlApiTestContainer::Draw(const TRect& aRect) const

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

//

void CBrCtlApiTestContainer::Draw(const TRect& aRect) const

    {

    CWindowGc& gc = SystemGc();

    // TODO: Add your drawing code here

    // example code...

    gc.SetPenStyle(CGraphicsContext::ENullPen);

    gc.SetBrushColor(KRgbGray);

    gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    gc.DrawRect(aRect);

    }

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

// CBrCtlApiTestContainer::HandleControlEventL(

//     CCoeControl* aControl,TCoeEvent aEventType)

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

//

void CBrCtlApiTestContainer::HandleControlEventL(

    CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)

    {

    // TODO: Add your control event handler code here

    }

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

// CBrCtlApiTestContainer::HandleKeyEventL(

//     const TKeyEvent& aKeyEvent,TEventCode /*aType*/)

// ?implementation_description

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

//

TKeyResponse CBrCtlApiTestContainer::HandleKeyEventL(

    const TKeyEvent& /*aKeyEvent*/,TEventCode /*aType*/)

    {

    return EKeyWasNotConsumed;

    }

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

// CBrCtlApiTestContainer::HandleCommandL(TInt aCommand)

// ?implementation_description

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

//

TInt CBrCtlApiTestContainer::HandleCommandL( TInt aCommand )

    {

    const TInt KCommandIdBase( 15000 );

    iBrCtlInterface->HandleCommandL( aCommand + KCommandIdBase );

    return KErrNone;

    }

TKeyResponse CBrCtlApiTestContainer::OfferKeyEventL(const TKeyEvent& /* aKeyEvent */,

                        TEventCode /* aType */ )

    {

    return EKeyWasConsumed;

    }

void CBrCtlApiTestContainer::HandleCommandL( 

    TBrCtlDefs::TBrCtlClientCommands /* aCommand */, 

    const CArrayFix<TPtrC>& /* aAttributesNames */,

    const CArrayFix<TPtrC>& /* aAttributeValues */ )

    {

    }

void CBrCtlApiTestContainer::CreateBrowserControlInterfaceL(TInt aBrCtlConfig)

    {

    TPoint base( 0, 0 );

    TPoint extent( 352, 295 );

    TRect rect( base, extent );

    iBrCtlInterface = CreateBrowserControlL( this, rect, 

        aBrCtlConfig,

        iCommandBase, iBrCtlApiTestObserver, iBrCtlApiTestObserver,

        iBrCtlApiTestObserver, iBrCtlApiTestObserver, iBrCtlDialogs, NULL, iBrCtlApiTestObserver );

    iBrCtlInterface->MakeVisible( ETrue );

    }

HBufC8* CBrCtlApiTestContainer::ReadFileLC( const TDesC& aFileName )

    {

    RFs rfs;

    RFile file;

    User::LeaveIfError( rfs.Connect() );

    CleanupClosePushL( rfs );

    User::LeaveIfError( file.Open( rfs, aFileName, EFileRead ) );

    CleanupClosePushL( file );

    TInt size;

    User::LeaveIfError( file.Size( size ) );

    HBufC8* buf = HBufC8::NewLC( size );

    TPtr8 bufPtr( buf->Des() );

    User::LeaveIfError( file.Read( bufPtr ) );

    CleanupStack::Pop(); // buf

    CleanupStack::PopAndDestroy( 2 ); // file, rfs

    CleanupStack::PushL( buf );

    return buf;

    }

TInt CBrCtlApiTestContainer::LoadDataL()

    {

    HBufC8* data = ReadFileLC( KUrlLoadTestHtml );

    TDataType dataType( KContentDataType() );

    TUid uid;

    uid.iUid = KCharacterSetIdentifierIso88591;

    TRAPD( err, iBrCtlInterface->LoadDataL( KUrlLoadTestHtml, *data, dataType, uid ) );

    CleanupStack::PopAndDestroy( data );

    return err;

    }

TInt CBrCtlApiTestContainer::ClearCacheTest()

    {

    const TUint result = iBrCtlInterface->ClearCache();

    return KErrNone;

    }

TBool CBrCtlApiTestContainer::IsUrlInCacheTest( TDesC16& aUrl )

    {

    const TBool result = iBrCtlInterface->IsUrlInCache( aUrl ); // ( TDesC16 & )KUrlLoadTestHtml() );

    return result;

    }

TInt CBrCtlApiTestContainer::ClearItemInCacheTest()

    {

    TInt result = iBrCtlInterface->ClearItemInCache( (TDesC16 &) KUrlLoadTestHtml() );

    if ( ( result == KErrNotFound ) || ( result == KErrNone ) )

        {

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }

    }

TInt CBrCtlApiTestContainer::PageInfoLC( TBrCtlDefs::TBrCtlPageInfo aType )

    {

    iBrCtlInterface->LoadFileL( KUrlLoadTestHtml );

    TRAPD( err, 

        HBufC* url = iBrCtlInterface->PageInfoLC( aType ); 

        CleanupStack::PopAndDestroy( url ); 

        )

    return err;

    }

TInt CBrCtlApiTestContainer::CertInfo()

    {

    const TCertInfo* certInfo = iBrCtlInterface->CertInfo();

    if ( !certInfo )

        {

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }

    }

TInt CBrCtlApiTestContainer::NavigationAvailableTest()

    {

    const TBool nav = iBrCtlInterface->NavigationAvailable( 

        TBrCtlDefs::ENavigationBack );

    if ( nav == 0 || nav == 1 )

        {

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }

    }

TInt CBrCtlApiTestContainer::GetBitmapData()

    {

    TRAPD( err, iBrCtlInterface->LoadUrlL(KUrlLoadTestHtml2) );

    //waits for browser control to load the page

    User::After(4000000);

    CGulIcon* icon = iBrCtlInterface->GetBitmapData( KUrlLoadTestHtml, TBrCtlDefs::EBitmapFavicon );

    icon = iBrCtlInterface->GetBitmapData( KUrlLoadTestHtml, TBrCtlDefs::EBitmapThumbnail );	

    return err;

    }

TInt CBrCtlApiTestContainer::SaveToFileL()

    {

    HBufC8* data = ReadFileLC( KUrlLoadTestHtml );

    TDataType dataType( KContentDataType() );

    TUid uid;

    uid.iUid = KCharacterSetIdentifierIso88591;

    TRAPD( err, iBrCtlInterface->LoadDataL( KUrlLoadTestHtml, *data, dataType, uid ) );

    TUint16 NoOfBytesSaved =  iBrCtlInterface->SaveToFileL( KUrlLoadTestHtml );

    CleanupStack::PopAndDestroy( data ); 

    return err;

    }

TInt CBrCtlApiTestContainer::OkToExit()

    {

    const TBool res = iBrCtlInterface->OkToExit();

    if ( res )

        {

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }

    }

TInt CBrCtlApiTestContainer::FindKeyword( TPtrC aHtml, TPtrC aKeyword, TInt aMatch)

    {

    TRAP_IGNORE( iBrCtlInterface->LoadFileL( KUrlLoadTestHtml2 ) );

    TInt result = iBrCtlInterface->FindKeyword( aKeyword );

    if ( result == TBrCtlDefs::EFindNoMatches && aMatch == EFindNoMatchesExpected )

        {

        return KErrNone;

        }

    else if ( result == TBrCtlDefs::EFindMatch && ( aMatch == EFindMatchExpected || aMatch == EFindMoreMatchesExpected ) )

        {

        return KErrNone;

        }

    else

        {

        return KErrNotFound;

        }

    }

TInt CBrCtlApiTestContainer::FindKeywordAgain( TInt aMatch )

    {

    TBrCtlDefs::TBrCtlFindResponse result = iBrCtlInterface->FindKeywordAgain( ETrue );

    if ( result == TBrCtlDefs::EFindNoMatches && ( aMatch == EFindNoMatchesExpected || aMatch == EFindMatchExpected ) )

        {

        return KErrNone;

        }

    else if ( result == TBrCtlDefs::EFindMatch && aMatch == EFindMoreMatchesExpected )

        {

        return KErrNone;

        }

    else

        {

        return KErrNotFound;

        }

    }

TInt CBrCtlApiTestContainer::SetFocus()

    {

    iBrCtlInterface->SetFocus( ETrue, EDrawNow );

    return KErrNone;

    }

TInt CBrCtlApiTestContainer::OfferKeyEvent()

    {

    TKeyEvent key;

    key.iCode = 0;

    key.iScanCode = 0;

    key.iModifiers = 0;

    key.iRepeats = 0;

    TRAPD( err, iBrCtlInterface->OfferKeyEventL( key, EEventNull ) );

    return err;

    }

TInt CBrCtlApiTestContainer::BrCtlMinimumSize()

    {

    const TSize testSize = iBrCtlInterface->MinimumSize();

    if ( testSize.iWidth > 0 && testSize.iHeight > 0 )

        {

        return KErrNone;

        }

    else

        {

        return KErrGeneral;

        }

    }

TInt CBrCtlApiTestContainer::BrCtlSubscribeToMenuItemsL()

    {

    TRAPD( err, iBrCtlInterface->LoadUrlL( KUrlLoadTestHtml2 ) );

	const RPointerArray<TBrCtlSubscribeTo> &ptr = iBrCtlInterface->SubscribeToMenuItemsL();

    return err;

    }    

TInt CBrCtlApiTestContainer::BrCtlContentSize()

    {

    TBool testPassed = EFalse;

    TSize testSize;

    if ( iBrCtlInterface )

        {

        testSize = iBrCtlInterface->ContentSize();

        if ( testSize.iWidth == 0 && testSize.iHeight == 0 )

            {

            testPassed = ETrue;

            }

        }

    return testPassed;

    }

TInt CBrCtlApiTestContainer::SetBrowserSettingL()

    {

    iBrCtlInterface->SetBrowserSettingL( TBrCtlDefs::ESettingsAutoLoadImages, 0 );

    return KErrNone;

    }

TInt CBrCtlApiTestContainer::BrowserSettingL( TUint& aSetting )

    {

    // value returned

    aSetting = iBrCtlInterface->BrowserSettingL( TBrCtlDefs::ESettingsAutoLoadImages );

    return KErrNone;

    }

TInt CBrCtlApiTestContainer::FocusedImageL()

    {

    iBrCtlInterface->LoadFileL( KUrlLoadTestHtml );

    iBrCtlInterface->SetFocus( ETrue, EDrawNow );

    TBrCtlImageCarrier* res = iBrCtlInterface->FocusedImageLC();

    CleanupStack::PopAndDestroy( res );

    if ( res )

        {

        return KErrNone; 

        }

    else 

        {

        return KErrGeneral;

        }        

    }

TInt CBrCtlApiTestContainer::AddCommandObserverL()

    {

    iBrCtlInterface->AddCommandObserverL( this );

    return KErrNone;

    }

TInt CBrCtlApiTestContainer::RemoveCommandObserver()

    {

    iBrCtlInterface->RemoveCommandObserver( this );

    return KErrNone;

    }

TInt CBrCtlApiTestContainer::ImageCountL()

    {

    return iBrCtlInterface->ImageCountL();

    }

TInt CBrCtlApiTestContainer::BrCtlFocusedElementTypeL()

    {

    iBrCtlInterface->LoadUrlL( KUrlLoadTestHtml2 );

    iBrCtlInterface->SetFocus( ETrue, EDrawNow );

    iBrCtlInterface->FocusedElementType();

    return KErrNone;

    }

TInt CBrCtlApiTestContainer::BrCtlSetParam()

    {

    _LIT( KContentType, "text/html");

    TRAPD( err, iBrCtlInterface->SetParamL( TBrCtlDefs::EParamsSelfDownoadableTypes, KContentType ) )

    return err;

    }

TInt CBrCtlApiTestContainer::LoadSavedPageL()

    {

    _LIT( KUid, "savedpage://4" );

    _LIT( KSavedUrl, "c:\\BrCtlTest\\loadtest.saved" );

    HBufC8* databuf = ReadFileLC( KSavedUrl );

    HBufC16* bigbuf = HBufC::NewL( databuf->Des().Length() );

    bigbuf->Des().Copy( databuf->Des() );

    iBrCtlInterface->LoadSavedPageL( KUid, *bigbuf );

    delete bigbuf;

    CleanupStack::PopAndDestroy( databuf ); 

    return KErrNone;