/*

* 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:  Manages widget windows, each window display one widget

*

*/

#include "WidgetUiWindowManager.h"

#include "WidgetUiWindowView.h"

#include "WidgetUiWindowContainer.h"

#include "WidgetUiWindow.h"

#include "WidgetUiAppUi.h"

#include "WidgetInstallerInternalCRKeys.h"

#include "SWInstWidgetUid.h"

#include "widgetappdefs.rh"

#include "Browser_platform_variant.hrh"

#ifdef BRDO_WRT_HS_FF

#include "cpspublisher.h"

#endif

#include <WidgetUi.rsg>

#include <BrCtlInterface.h>

#include <WidgetRegistryConstants.h>

#include <centralrepository.h>

#include <StringLoader.h>

#include <AknNoteDialog.h>

#include <BrowserDialogsProvider.h>

#include <S32FILE.H>

#include <aknnotewrappers.h>

#include "cpglobals.h" // CPS string definitions.

#include <InternetConnectionManager.h>

#include <ActiveApDb.h>

    {

protected: // From CActive

    /**

    * Execute asynchronous operation.

    */

    void RunL();

    /**

    * Provide cancellation methods.

    */

    void DoCancel();

private:

    /**

    * Constructor.

    */

    /**

    * Destructor. 

    *

    * Private on purpose.

    */

private:

// =============================================================================

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

// CWidgetUiWindowManager::CWidgetUiWindowManager()

// Default constructor

//

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

//

CWidgetUiWindowManager::CWidgetUiWindowManager(CWidgetUiAppUi& aAppUi):

    iAppUi(aAppUi),

    {

    }

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

// CWidgetUiWindowManager::ConstructL()

// Symbian constructor

//

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

//

void CWidgetUiWindowManager::ConstructL()

    {

    CRepository* cenRep(NULL);

    CCoeEnv::Static()->FsSession().CreatePrivatePath( EDriveC );

    // Create the client-side session

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

    iServerConnected = ETrue;

    TRAPD(error,cenRep = CRepository::NewL( TUid::Uid( KSWInstWidgetUIUid ) ));

    if (!error)

        {

        TInt strictMode;

        if (cenRep->Get( KWidgetInstallerStrictMode, strictMode ) == KErrNone)

            {

            iStrictMode = strictMode;

            }

        delete cenRep;

        }

    iDialogsProvider = CBrowserDialogsProvider::NewL( NULL );

    iHandler = CDocumentHandler::NewL(CEikonEnv::Static()->Process());

    iDb = CActiveApDb::NewL( EDatabaseTypeIAP );

    iConnection = CInternetConnectionManager::NewL( iDb->Database(), EFalse );

#ifdef BRDO_WRT_HS_FF    

    iCpsPublisher = CCpsPublisher::NewL();

#endif

    }

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

// CWidgetUiWindowManager::NewL

// Two-phased constructor

//

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

//

CWidgetUiWindowManager* CWidgetUiWindowManager::NewL( CWidgetUiAppUi& aAppUi )

    {

    CWidgetUiWindowManager* self = new ( ELeave ) CWidgetUiWindowManager( aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWidgetUiWindowManager::~CWidgetUiWindowManager()

// Destructor

//

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

//

CWidgetUiWindowManager::~CWidgetUiWindowManager()

    {

    iWindowList.ResetAndDestroy();

    // TODO Why there is a "Disconnect" method in the first place...

    // RHandleBase::Close() should be enough?

    if ( iServerConnected )

        {

        iClientSession.Disconnect();

        }

    iClientSession.Close();

    delete iHandler;

    delete iDialogsProvider;

    if ( iConnection )

        {

        TRAP_IGNORE( iConnection->StopConnectionL() );

        }

    delete iConnection;

#ifdef BRDO_WRT_HS_FF  

    delete iCpsPublisher;

#endif

    delete iDb;

    }

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

// CWidgetUiWindowManager::DeactivateMiniViewL()

// Stop MiniView. Stops publishing and exits widget

//

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

//

    {

    CWidgetUiWindow* wdgt_window = GetWindow(aUid);

    if(!wdgt_window)

    wdgt_window->SetWindowStateMiniViewL( EMiniViewEnabled );

    // TODO also other states are possible when we should react?

    // Removing . Miniview, shall remove full view as well. For blanket permissions

    // will be revoked for miniview

    iClientSession.SetMiniViewL( aUid, EFalse );

    }

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

// CWidgetUiWindowManager::ActivateMiniView()

// Start publishing offscreenbitmap  to HS.

//

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

//

TBool CWidgetUiWindowManager::ActivateMiniViewL( 

    const TUid& aUid, 

    const TRect& aRect )

    {

    TBool res( EFalse );

    CWidgetUiWindow* wdgt_window( GetWindow( aUid ) );

    __ASSERT_DEBUG( wdgt_window, User::Invariant() );

    if ( wdgt_window->WidgetMiniViewState() != EMiniViewNotEnabled )

        {

        // We could throw User::Invariant() if state == EPublishStart, but that would be nasty...

        if ( wdgt_window->WidgetMiniViewState() != EPublishStart )

            {            

            iClientSession.SetMiniViewL( aUid, ETrue );

            HideWindow( iActiveFsWindow );

            //This is done to prevent offscreen bit map overlap 

            //when widget selected from FSW

            }

        res = ETrue;

        }

    return res;

    }

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

// CWidgetUiWindowManager::HandleWidgetCommandL()

// Open or close widget window

//

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

//

void CWidgetUiWindowManager::HandleWidgetCommandL( 

    const TUid& aUid,

    TUint32 aOperation )

    {

    switch ( aOperation )

        {

        case LaunchFullscreen:

        case LaunchMiniview:

            {

            OpenOrCreateWindowL( aUid, aOperation );

            }

            break;

        case Deactivate:

            {

            }

            break;

        case WidgetResume:

            {

            ResumeWidgetL( aUid );

            }

            break;

        case WidgetSuspend:

            {

            SuspendWidget( aUid );

            }

            break;

        case WidgetSelect:

            // If we don't have window we know that WidgetUI has died

            // We must enable miniview state

                }

            //WidgetLauncher modified to bring app to foreground

            }

            break;

        }

    }

void CWidgetUiWindowManager::OpenOrCreateWindowL( 

    const TUid& aUid,

    TUint32 aOperation )

    {

    CWidgetUiWindow* wdgt_window( GetWindow( aUid ) );

    TBool setFullViewState(EFalse);

#ifdef BRDO_WRT_HS_FF

    TSize miniviewSize( iCpsPublisher->BitmapSize());

#else

    TSize miniviewSize( 0,0 );

#endif

    if( wdgt_window ) 

        {

        // This might come from app shell as well where appshell window needs to be resized

        // then active window should be set

        //  if active window is there hide it

        // set the new window as current and active. Chcek if window needs resizing and set the registry as fullView and active

        // can be checked , we can launch in full view if Rect size is same as view size

        if ( aOperation == LaunchMiniview )

            {

            if ( !ActivateMiniViewL( aUid, miniviewSize ) )

                {

                wdgt_window = NULL;

                }

            }

        // If the existing widget is in miniview state, we need to make it full-screen.

        // Sanity check that we don't have to do anything extra.

        else 

            {

#ifdef BRDO_WRT_HS_FF

            //Make sure that all the mini widgets are already suspended

            SuspendAllWidget();

#endif

            // TODO Combine these methods somewhere in WidgetUiWindow, so it knows

            // how to tamper its own internal state. For example MakeFullScreen().

            setFullViewState = ETrue;

            iClientSession.SetFullViewL( aUid, ETrue );

            }

        }

    else

        {

        // Create a new window.

        if ( !IsWidgetAllowedL( aUid ) )

            {

            ShowNoteDialogL( R_WIDGETUI_STRICT_MODE_ACCESS );

            iAppUi.SendAppToBackground();

            }

        else 

            {

            // Does the widget support miniviews, in case that is desired?

            if ( aOperation == LaunchFullscreen || DoesWidgetSupportMiniviewL( aUid ) )

                {

                if ( aOperation == LaunchFullscreen )

                    iClientSession.SetFullViewL( aUid, ETrue );

                // Create window.

                wdgt_window = CreateNewWidgetWindowL( aUid );

                if ( aOperation )

                    {

                    // Don't care if this returns, we know miniviews are supported.

                    TRAPD( err, ActivateMiniViewL( aUid, miniviewSize ) );

                    if ( err )

                        {

                        CloseWindow( wdgt_window );

                        wdgt_window = NULL;

                        }

                    }

                else

                    {

#ifdef BRDO_WRT_HS_FF

                    SuspendAllWidget();

#endif

                    setFullViewState = ETrue;

                    }

                }

            }

        }

    // Windows are up & running. Hopefully.

    if ( wdgt_window  )

        {

        if ( iActiveFsWindow != wdgt_window )

            {

            HideWindow( iActiveFsWindow );

            }

        if( setFullViewState )

            {

            iActiveFsWindow = wdgt_window;

            iActiveFsWindow->SetWindowStateFullView(ETrue);

            if ( iActiveFsWindow->Engine()->Rect() != View()->ClientRect())

                {

                iActiveFsWindow->Engine()->SetRect( View()->ClientRect() );

                }

            //iActiveFsWindow->Engine()->MakeVisible( ETrue );

            }

        }

    iClientSession.SetActive( aUid, ETrue );

    }

// =============================================================================

// CWidgetUiWindowManager::GetWindow()

// return the window of a widget with a particular url

//

// =============================================================================

//

CWidgetUiWindow* CWidgetUiWindowManager::GetWindow( const TDesC& aUrl )

    {

    for ( TInt i = 0; i < iWindowList.Count(); i++ )

        {

        CWidgetUiWindow* window = iWindowList[i];

        if ( window->Url()->Des() == aUrl )

            {

            return window;

            }

        }

    return NULL;

    }

// =============================================================================

// CWidgetUiWindowManager::GetWindow()

// return the window of a widget with a particular Uid

//