/*

* Copyright (c) 2005 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: 

*      Implementation of CBrowserWindowSelectionView.

*

*

*/

// INCLUDE FILES

#include <aknviewappui.h>

#include <avkon.hrh>

#include <BrowserNG.rsg>

#include <FeatMgr.h>

#include <avkon.RSG>

#include <eikbtgpc.h>

#include <akntabgrp.h>

#include <aknnavi.h>

#include <brctlinterface.h>

#include <brctldefs.h>

#include "BrowserAppUi.h"

#include "CommonConstants.h"

#include "BrowserWindowSelectionView.h"

#include "BrowserWindowSelectionContainer.h" 

#include "Preferences.h"

#include "Display.h"

#include "BrowserWindowManager.h"

#include "BrowserWindow.h"

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

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

// CBrowserWindowSelectionView::NewLC

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

//

CBrowserWindowSelectionView* CBrowserWindowSelectionView::NewLC( MApiProvider& aApiProvider )

    {

    CBrowserWindowSelectionView* view = new (ELeave) CBrowserWindowSelectionView( aApiProvider );

    CleanupStack::PushL( view );

    view->ConstructL( );    

    return view;

    }

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

// CBrowserWindowSelectionView::CBrowserWindowSelectionView

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

//

CBrowserWindowSelectionView::CBrowserWindowSelectionView( MApiProvider& aApiProvider ):

CBrowserViewBase( aApiProvider )

    {

    }

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

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

// EPOC two-phased constructor

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

//

void CBrowserWindowSelectionView::ConstructL()

    {

    BaseConstructL( R_BROWSERWINDOWSELECTION_VIEW );    

    iTitles = new (ELeave) CArrayFixFlat<HBufC*>( 2 );

    iWindowIds = new (ELeave) CArrayFixFlat<TInt>( 2 );

    }

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

// CBrowserWindowSelectionView::~CBrowserWindowSelectionView()

// destructor

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

//

CBrowserWindowSelectionView::~CBrowserWindowSelectionView()

    {

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        }

    delete iContainer;

    delete iWindowInfo;

    delete iTitles;

    delete iWindowIds;

    }

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

// TUid CBrowserWindowSelectionView::Id()

//

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

//

TUid CBrowserWindowSelectionView::Id() const

    {

    return KUidBrowserWindowSelectionViewId;

    }

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

// CBrowserWindowSelectionView::CommandSetResourceIdL

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

TInt CBrowserWindowSelectionView::CommandSetResourceIdL()

    {

    TInt commandSet = 0; // R_AVKON_SOFTKEYS_EMPTY;

    return commandSet;

    }  

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

// CBrowserWindowSelectionView::HandleCommandL()

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

//

void CBrowserWindowSelectionView::HandleCommandL(TInt aCommand)

    {   

    switch ( aCommand )

        {

        case EAknCmdOpen:

            {

            TInt windowId = GetWindowIdFromTabIndex( iContainer->GetTabGroup()->ActiveTabIndex() );

            ApiProvider().WindowMgr().SwitchWindowL( windowId );

            //If the user switches window we reset the CalledFromAnotherApp status

        	if(ApiProvider().CalledFromAnotherApp())

            	{

            	ApiProvider().SetCalledFromAnotherApp(EFalse);

            	}

            ApiProvider().SetViewToBeActivatedIfNeededL( GetPreviousViewID() );

            break;                

            }

        case EWmlCmdCloseWindow:

            {            

            TInt windowId = GetWindowIdFromTabIndex( iContainer->GetTabGroup()->ActiveTabIndex() );

            TInt newWindowId = ApiProvider().WindowMgr().DeleteWindowL( windowId, EFalse );

            // Check if there is only one remaining window,

            // after closing the window.

            delete iWindowInfo;

            iWindowInfo = NULL;

            iWindowInfo = ApiProvider().WindowMgr().GetWindowInfoL( this );

            if ( iWindowInfo->Count() < 2 )

                {

                ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserContentViewId );

                ApiProvider().WindowMgr().SwitchWindowL( newWindowId );                

                }

            break;                

            }            

        case EWmlCmdCloseAllWindowButThis:

            {

            iWindowEventsDisabled = ETrue;

            // Get current window id.

            TInt windowId = GetWindowIdFromTabIndex( iContainer->GetTabGroup()->ActiveTabIndex() );

            // Get all windows id.

            delete iWindowInfo;

            iWindowInfo = NULL;

            iWindowInfo = ApiProvider().WindowMgr().GetWindowInfoL( this );

            // Delete all windows except this.            

            for ( TInt i = 0; i < iWindowInfo->Count(); i++ )

                {                

                if ( (*iWindowInfo)[i]->iWindowId != windowId )

                    {

                    ApiProvider().WindowMgr().DeleteWindowL( (*iWindowInfo)[i]->iWindowId, ETrue );                    

                    }                    

                }

            // Activate curent window.

            ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserContentViewId );

            ApiProvider().WindowMgr().SwitchWindowL( windowId );

            iWindowEventsDisabled = EFalse;            

            break;                

            }            

        case EWmlCmdWindowSelectionCancel:

            {

            ApiProvider().SetViewToBeActivatedIfNeededL( KUidBrowserContentViewId );

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CBrowserWindowSelectionView::HandleClientRectChange()

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

//

void CBrowserWindowSelectionView::HandleClientRectChange()

    {

    if ( iContainer )

        {

        iContainer->SetRect( ClientRect() );

        }

    }

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

// CBrowserWindowSelectionView::DoActivateL(...)

// 

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

//

void CBrowserWindowSelectionView::DoActivateL( const TVwsViewId& aPrevViewId,TUid /*aCustomMessageId*/,

                                               const TDesC8& /*aCustomMessage*/)

    {    

    StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL );

    StatusPane()->MakeVisible( ETrue );

    iPreviousViewID = ApiProvider().LastActiveViewId( );

    ApiProvider().SetLastActiveViewId( Id() );

    iLastViewId = aPrevViewId;

    if (!iContainer)

        {

        iContainer = new (ELeave) CBrowserWindowSelectionContainer( this );

        iContainer->SetMopParent(this);

        iContainer->ConstructL( ClientRect() );

        AppUi()->AddToStackL( *this, iContainer );

        UpdateTabsL();

        }

    ApiProvider().WindowMgr().AddObserverL( this );        

    }

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

// CBrowserWindowSelectionView::DoDeactivate()

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

//

void CBrowserWindowSelectionView::DoDeactivate()

    {

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        }

    delete iContainer;

    iContainer = NULL;

    ApiProvider().WindowMgr().RemoveObserver( this );    

    }

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

// CBrowserWindowSelectionView::CreateWindowInfoLC()

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

//    

HBufC* CBrowserWindowSelectionView::CreateWindowInfoLC( const CBrowserWindow& aWindow )

    {

    HBufC* buf = aWindow.BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoTitle );

    if( !buf || !buf->Length() )

        {

        CleanupStack::PopAndDestroy( buf );

        buf = aWindow.BrCtlInterface().PageInfoLC( TBrCtlDefs::EPageInfoUrl );

        }

    return buf;

    }

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

// CBrowserWindowSelectionView::UpdateTabs()

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

//        

void CBrowserWindowSelectionView::UpdateTabsL()

    {

    delete iWindowInfo;

    iWindowInfo = NULL;

    iWindowInfo = ApiProvider().WindowMgr().GetWindowInfoL( this );

    iTitles->Reset();

    iWindowIds->Reset();

    TInt activeTab = 0;

    for ( TInt i = 0; i < iWindowInfo->Count(); i++ )

        {

        iTitles->AppendL( CONST_CAST( HBufC*, (*iWindowInfo)[i]->iWindowText ) );

        iWindowIds->AppendL( (*iWindowInfo)[i]->iWindowId );

        if ( (*iWindowInfo)[i]->iCurrent )

            {

            activeTab = i;

            HBufC* title = CONST_CAST( HBufC*, (*iWindowInfo)[i]->iWindowText );

            if ( title )

                {

                ApiProvider().Display().SetTitleL( title->Des() );

                }                

            }

        }

    iContainer->ChangeTabL( iTitles, activeTab );

    }

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

// CBrowserWindowSelectionView::UpdateTabs()

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

//        

void CBrowserWindowSelectionView::UpdateTumbnailL()

    {

    TInt windowId = GetWindowIdFromTabIndex( iContainer->GetTabGroup()->ActiveTabIndex() );

    iContainer->GetWindowThumbnailL( windowId );

    iContainer->DrawNow();

    }

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

// CBrowserWindowSelectionView::UpdateTitleL()

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

//        

void CBrowserWindowSelectionView::UpdateTitleL( )

    {    

    HBufC* title = GetWindowTitleFromTabIndex( iContainer->GetTabGroup()->ActiveTabIndex() );

    ApiProvider().Display().SetTitleL( (*title).Des( ) );

    }

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

// CBrowserWindowSelectionView::GetWindowIdFromTabIndex

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

//

TInt CBrowserWindowSelectionView::GetWindowIdFromTabIndex( TInt aActiveTabIndex )

    {

    TInt windowId = 0;

    for ( TInt i = 0; i < iWindowIds->Count(); i++ )

        {

        if ( i ==  aActiveTabIndex ) 

            {

            windowId = (*iWindowInfo)[i]->iWindowId;

            }

        }

    return windowId;

    }

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

// CBrowserWindowSelectionView::GetWindowIdFromTabIndex

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

//

HBufC* CBrowserWindowSelectionView::GetWindowTitleFromTabIndex( TInt aActiveTabIndex )

    {

    HBufC*  windowText = NULL;

    for ( TInt i = 0; i < iWindowInfo->Count(); i++ )

        {        

        if ( i ==  aActiveTabIndex ) 

            {

            windowText = CONST_CAST( HBufC*, (*iWindowInfo)[i]->iWindowText );

            }

        }

    return windowText;

    }

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

// CBrowserWindowSelectionView::WindowEventHandlerL

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

//

void CBrowserWindowSelectionView::WindowEventHandlerL( TWindowEvent aEvent, TInt /*aWindowId*/ )

    {

    if ( !iWindowEventsDisabled )

        {            

        if ( aEvent == EWindowClose || aEvent == EWindowOpen )

            {

            delete iWindowInfo;

            iWindowInfo = NULL;

            iWindowInfo = ApiProvider().WindowMgr().GetWindowInfoL( this );

            // Update tabs when there are more than one windows open.

            if ( iWindowInfo->Count() > 1 )

                {        

                UpdateTabsL();

                }            

            }            

        if ( aEvent == EWindowLoadStart )

            {

            iEikonEnv->InfoMsg( _L("load start") );

            }            

        if ( aEvent == EWindowLoadStop )

            {

            iEikonEnv->InfoMsg( _L("load stop") );

            }            

        }

    }

// End of File