/*

* Copyright (c) 2006, 2008 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: 

*

*/

#include "WidgetUi.hrh"

#include "WidgetUiWindow.h"

#include "WidgetUiWindowView.h"

#include "WidgetUiWindowContainer.h"

#include "WidgetUiWindowManager.h"

#include "WidgetUiDialogsProviderProxy.h"

#include "WidgetRegistryConstants.h"

#include "Browser_platform_variant.hrh"

#ifdef BRDO_WRT_HS_FF

#include "cpspublisher.h"

#endif

#include <AknUtils.h>

#include <ImageConversion.h>

#include <WidgetUi.rsg>

#include <schemehandler.h>

#include <InternetConnectionManager.h>

#include "WidgetInstallerInternalCRKeys.h"

#include <BrowserUiSDKCRKeys.h>

#include <StringLoader.h>

#include <centralrepository.h>

#include <ApUtils.h>

#include <AiwGenericParam.h>

#include <ActiveApDb.h>

#include <aknsdrawutils.h>

#include "SWInstWidgetUid.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

static const TUint32 KDummyCommand = 0;

const TUint KWmlNoDefaultAccessPoint = KMaxTUint; // see cenrep setting default -1 as int, here as uint

const TUint KWmlNoDefaultSnapId = KMaxTUint; // see cenrep setting default -1 as int, here as uint

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

static HBufC* GetUlrL(

    RWidgetRegistryClientSession& aSession,

    const TUid& aUid );

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

HBufC* GetUlrL(

    RWidgetRegistryClientSession& aSession,

    const TUid& aUid )

    {

    CWidgetPropertyValue* val( aSession.GetWidgetPropertyValueL( aUid, EMainHTML ) );

    CleanupStack::PushL( val );

    HBufC* res( static_cast< const TDesC& >( *val ).AllocL() );

    CleanupStack::PopAndDestroy( val );

    return res;

    }

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

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

// CWidgetUiWindow::CWidgetUiWindow()

// C++ constructor

//

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

//

CWidgetUiWindow::CWidgetUiWindow( CWidgetUiWindowManager& aWindowManager, CCpsPublisher* aCpsPublisher )

    : iWindowManager( aWindowManager ), iCpsPublisher( aCpsPublisher ), iNetworkAccessGrant(EInvalid),

      iPreferredOrientation(TBrCtlDefs::EOrientationUndefined),

      iIsCurrent(EFalse), iShowSoftkeys(EFalse), iWidgetLoaded(EFalse),

    {

    }

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

// CWidgetUiWindow::ConstructL()

// Symbian constructor

//

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

//

void CWidgetUiWindow::ConstructL( const TUid& aUid )

    {

    iUid = aUid;

    iPenEnabled = AknLayoutUtils::PenEnabled();

    iShowSoftkeys = iPenEnabled;

    CWidgetUiWindowView* view = iWindowManager.View();

    // view->ShowActivatedObject(EFalse);

    //TRect rect( view->Container()->Rect() );

    TRect rect;

    RWidgetRegistryClientSession clientSession = iWindowManager.WidgetUIClientSession();

    iUrl = GetUlrL( clientSession, aUid );

    iWidgetUiObserver = CWidgetUiObserver::NewL( *this );

    iWidgetUiDialogsProviderProxy = CWidgetUiDialogsProviderProxy::NewL(*(iWindowManager.DialogsProvider()), NULL, *this);

    iEngine = CreateBrowserControlL(

        view->Container(),

        rect,

        TBrCtlDefs::ECapabilityLoadHttpFw |

        TBrCtlDefs::ECapabilityCursorNavigation|

        TBrCtlDefs::ECapabilityWebKitLite |

        TBrCtlDefs::ECapabilityClientResolveEmbeddedURL,

        TBrCtlDefs::ECommandIdBase,

        iWidgetUiObserver, /* softkeys */

        iWidgetUiObserver, /* link resolver */

        this, /* special load observer */

        iWidgetUiObserver, /* layout observer */

        iWidgetUiDialogsProviderProxy,

        iWidgetUiObserver, /* window observer */

        iWidgetUiObserver /* download observer */);

    iEngine->AddLoadEventObserverL( iWidgetUiObserver );

    iEngine->AddStateChangeObserverL( view );

    iEngine->SetComponentsToInheritVisibility();

    iWidgetExtension = iEngine->CreateWidgetExtensionL( *this );

    iWidgetExtension->SetParamL( TBrCtlDefs::EWidgetIdentifier, aUid.iUid );

    iWidgetBundleId = HBufC::NewL(KWidgetRegistryVal);

    TPtr widgetBundleId = iWidgetBundleId->Des();

    iWidgetPath = HBufC::NewL(KWidgetRegistryVal);

    TPtr widgetPath = iWidgetPath->Des();

    clientSession.GetWidgetBundleId( aUid, widgetBundleId );

    clientSession.GetWidgetPath( aUid, widgetPath );

    iWidgetExtension->SetParamL( TBrCtlDefs::EWidgetBasePath, widgetPath );

    iWidgetExtension->SetParamL( TBrCtlDefs::EWidgetBundleId, widgetBundleId );

    //    SetSoftkeysVisible(iPenEnabled);// default softkeys visible for touch and invisible for non-touch

    //iEngine->MakeVisible( EFalse );

    // Updating Widget UI window state

    if(HasMiniviewL())

        {

        SetWindowStateMiniViewL( EMiniViewEnabled );

        }

    else

        {

        SetWindowStateMiniViewL( EMiniViewNotEnabled );

        }

    iDlId = 0;

    }

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

// CWidgetUiWindow::~CWidgetUiWindow()

// Destructor

//

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

//

CWidgetUiWindow::~CWidgetUiWindow()

    {

    if (iEngine && iWidgetUiObserver)

        {

        iEngine->RemoveLoadEventObserver( iWidgetUiObserver );

        iEngine->RemoveStateChangeObserver( iWindowManager.View() );

        }

    delete iEngine;

    delete iWidgetUiObserver;

    delete iUrl;

    delete iWidgetPath;

    delete iWidgetBundleId;

    delete iRightSoftKeyLabel;

    delete iLeftSoftKeyLabel;

    delete iWidgetUiDialogsProviderProxy;

    delete iSchemeHandler;

    }

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

// CWidgetUiWindow::CbaGroup()

// returns cba group

//

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

//

CEikButtonGroupContainer* CWidgetUiWindow::CbaGroup()

    {

    return iWindowManager.View()->CbaGroup();

    }

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

// CWidgetUiWindow::OpenWindowL()

// Creates CWidgetUiWindow object

//

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

//

CWidgetUiWindow* CWidgetUiWindow::OpenWindowL( CWidgetUiWindowManager& aWindowManager,

                                         const TUid& aUid, CCpsPublisher* aCpsPublisher )

    {

    CWidgetUiWindow* window = new ( ELeave ) CWidgetUiWindow( aWindowManager, aCpsPublisher );

    CleanupStack::PushL( window );

    window->ConstructL( aUid );

    CleanupStack::Pop( window );

    return window;

    }

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

// CWidgetUiWindow::setWindowStateFullView()

// Sets the widget state if widget is opened in full view

//

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

//

void CWidgetUiWindow::SetWindowStateFullView( TBool aWidgetFullViewState)

    {

    iWidgetWindowState.iFullViewState = aWidgetFullViewState;

    }

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

// CWidgetUiWindow::setWindowStateMiniView()

// Sets the MiniView widget state

//

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

//

/*void CWidgetUiWindow::SetWindowStateMiniView( TInt widgetMiniViewState )

    {

    switch(widgetMiniViewState)

    	{

        case 0: iWidgetWindowState.miniViewState = EMiniViewNotEnabled;

                break;

        case 1: iWidgetWindowState.miniViewState = EMiniViewEnabled;

                break;

        case 2: iWidgetWindowState.miniViewState = EPublishStart;

                break;

        case 3: iWidgetWindowState.miniViewState = EPublishSuspend;

                break;

        }

    }

    */

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

// CWidgetUiWindow::setWindowStateMiniView()

// Sets the MiniView widget state

//

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

//

void CWidgetUiWindow::SetWindowStateMiniViewL( TMiniViewState widgetMiniViewState)

    {

    iWidgetWindowState.iMiniViewState = widgetMiniViewState;

    if (  iWidgetWindowState.iMiniViewState == EPublishStart )

        iWidgetExtension->SetParamL( TBrCtlDefs::EWidgetPublishState, ETrue);

    else

        iWidgetExtension->SetParamL( TBrCtlDefs::EWidgetPublishState, EFalse);

    }

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

// CWidgetUiWindow::getWidgetMiniViewState()

// Get  the MiniView widget state

//

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

//

TMiniViewState CWidgetUiWindow::WidgetMiniViewState() const

    {

    return iWidgetWindowState.iMiniViewState;

    }

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

// CWidgetUiWindow::getWidgetFullViewState()

// Get  the FullView widget state

//

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

//

TBool CWidgetUiWindow::WidgetFullViewState() const

    {

    return iWidgetWindowState.iFullViewState;

    }

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

// CWidgetUiWindow::DialogMimeFileSelectLC()

// Navigates through your file system and selects a file of specific mime type

//

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

//

TBool CWidgetUiWindow::DialogMimeFileSelectLC(HBufC*& aSelectedFileName,

                                 const TDesC& aMimeType)

    {

    return iWindowManager.DialogsProvider()->DialogMimeFileSelectLC(aSelectedFileName, aMimeType);

    }

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

// CWidgetUiWindow::SetSoftkeysVisible()

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

//

void CWidgetUiWindow::SetSoftkeysVisible(TBool aVisible)

    {

    iShowSoftkeys = (aVisible);

    if (CbaGroup())

        {

        CbaGroup()->MakeVisible( iShowSoftkeys );

        CbaGroup()->DrawNow();

        TRect clientRect = iWindowManager.View()->ClientRect();

        // resize the container to take into account the size of the softkey labels

        // reduction is only needed for portrait mode (softkey on bottom) since landscape

        // mode softkeys don't take up screen real estate

        if (AknLayoutUtils::CbaLocation() == AknLayoutUtils::EAknCbaLocationBottom)

            {

            CbaGroup()->ReduceRect(clientRect);

            }

        //Check if the container rect needs change and then call setRect

        if(clientRect != iWindowManager.View()->Container()->Rect())

           iWindowManager.View()->Container()->SetRect(clientRect);

        }

    }

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

// CWidgetUiWindow::SetDisplayMode()

// switch the display orientation to landscape or portrait

//

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

//

void CWidgetUiWindow::SetDisplayMode( TBrCtlDefs::TBrCtlOrientation aOrientation )

    {

    if (aOrientation != TBrCtlDefs::EOrientationUndefined)

        {

        iPreferredOrientation = aOrientation;

        }

    switch (iPreferredOrientation)

        {

        case TBrCtlDefs::EOrientationLandscape:

            {

            iWindowManager.SetDisplayLandscape();

            break;

            }

        case TBrCtlDefs::EOrientationPortrait:

            {

            iWindowManager.SetDisplayPortrait();

            break;

            }

        default:

            {

            iWindowManager.SetDisplayAuto();

            break;

            }

        }

    }

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

// CWidgetUiWindow::SetSoftKeyLabelL()

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

//

void CWidgetUiWindow::SetSoftKeyLabelL( TBrCtlKeySoftkey aKeySoftkey, const TDesC& aText)

    {

    TInt command;

    if (aKeySoftkey == EKeyLeft)

        {

        command = EAknSoftkeyOptions;

        // save the softkey label if it changes

        if (iLeftSoftKeyLabel && iLeftSoftKeyLabel->Compare(aText))

            {

            delete iLeftSoftKeyLabel;

            iLeftSoftKeyLabel = NULL;

            }

        if (!iLeftSoftKeyLabel)

            {

            iLeftSoftKeyLabel = aText.AllocL();

            }

        }

    else // EKeyRight

        {

        command = EAknSoftkeyExit;

        // save the softkey label if it changes

        if (iRightSoftKeyLabel && iRightSoftKeyLabel->Compare(aText))

            {

            delete iRightSoftKeyLabel;

            iRightSoftKeyLabel = NULL;

            }

        if (!iRightSoftKeyLabel)

            {

            iRightSoftKeyLabel = aText.AllocL();

            }

        }

    // make sure softkeys are visible before setting the text

    // CEikButtonGroupContainer::Current() returns NULL if softkeys are not visible

    TInt err(KErrNotFound);

    // check to see if aText is a filename

    if (aText.Find(_L(".")) != KErrNotFound)

        {

        TRAP(err,SetSoftKeyImageL( command, aText ));

        }

    if (CbaGroup())

        {

        if (err != KErrNone)

            {

            CbaGroup()->SetCommandL( command, aText );

            }

        CbaGroup()->DrawDeferred();

        }

    }

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

// CWidgetUiWindow::SetSoftKeyImageL()

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

//

void CWidgetUiWindow::SetSoftKeyImageL(const TInt aCommand, const TDesC& aFilename)

    {

    HBufC* filename = HBufC::NewLC( iUrl->Length() + aFilename.Length() );

    TPtr ptr(filename->Des());

    TInt last = iUrl->LocateReverse('\\');

    if (last > 0)

        {

        ptr.Append(iUrl->Left(++last));

        }

    ptr.Append(aFilename);

    ptr.ZeroTerminate();

    RFs& server( CCoeEnv::Static()->FsSession() );

    CImageDecoder *iImageDecoder = CImageDecoder::FileNewL(server,

               ptr,

               CImageDecoder::EOptionAlwaysThread);

    TFrameInfo info = iImageDecoder->FrameInfo();

    TRect      rect = info.iFrameCoordsInPixels;

    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    CFbsBitmap* mask = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(mask);

    bitmap->Create( rect.Size(), info.iFrameDisplayMode );

    mask->Create( rect.Size(), EGray256 );

    TRequestStatus Status;

    iImageDecoder->Convert( &Status, *bitmap, *mask );

    User::WaitForRequest( Status );

    delete iImageDecoder;

    iImageDecoder = NULL;

    //bitmap->Compress();

    if (CbaGroup())

        {

        CbaGroup()->SetCommandL( aCommand, *bitmap, *mask ); // FYI This hasn't been implemented

        }

    CleanupStack::PopAndDestroy(3);// filename,bitmap,mask

    }

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

// CWidgetUiWindow::Relayout()

// switch the display orientation based on preferred setting

//

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

//

void CWidgetUiWindow::Relayout( )

    {

    if (iIsCurrent)

        {

        SetDisplayMode(iPreferredOrientation);

        SetSoftkeysVisible(iShowSoftkeys);

        //iWindowManager.View()->Container()->SizeChanged();

        }

    }

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

// CWidgetUiWindow::SetCurrentWindow()

// sets this window current or not and resets the previous state

//

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

//

void CWidgetUiWindow::SetCurrentWindow( TBool aCurrent )

    {

        {

        iIsCurrent = aCurrent;

        if (aCurrent)

            {

            UpdateCba();

            Engine()->MakeVisible( iWidgetLoaded );

            // redraw incase the orientation changed while in the background

            Relayout();

            }

        else

            {

            // close the menu

            iWindowManager.View()->StopDisplayingMenuBar();

            //deactivate optionsmenu flag

            iWindowManager.View()->DeActivateOptionsMenu();

            Engine()->MakeVisible(EFalse);// hide the active widget

            }