/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <bautils.h>

#include <eikon.hrh>

#include <eikbtgpc.h>

#include <eikenv.h>

#include <avkon.rsg>

#include <aknenv.h>

#include <akncontext.h>

#include <akntitle.h>

#include <aknnavide.h>

#include <AknsUtils.h>

#include <eswtcore.rsg>

#include <AknUtils.h>

#include <AknsDrawUtils.h>

#include <AknTextDecorationMetrics.h>

#ifdef RD_JAVA_S60_RELEASE_9_2

#include <AknPriv.hrh>

#include <aknappui.h>

#endif

#include <coreuiavkoneswt.h>

#include <swtlaffacade.h>

#include "eswtmobileextensions.h"

#include "eswtwidgetsexpanded.h"

#include "swtcontrolhelper.h"

#include "swtmessagebox.h"

#include "swtuiutils.h"

#include "swtbrowser.h"

#include "swtdisplaybase.h"

_LIT(KSeparator, "-");

const TInt KVariationFullScreen = 3;

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

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

// CSwtUiUtils::NewL

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

//

CSwtUiUtils* CSwtUiUtils::NewL(MSwtDisplay& aDisplay)

{

    CSwtUiUtils* self = new(ELeave) CSwtUiUtils(aDisplay);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtUiUtils::~CSwtUiUtils

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

//

CSwtUiUtils::~CSwtUiUtils()

{

    ASSERT(iShells.Count() == 0);

    iShells.Close();

    delete iCba;

    iCba = NULL;

    iStatusPane = NULL;

    delete iNaviDecorator;

    iNaviDecorator = NULL;

    iActiveShell = NULL;

    iNextActiveShell = NULL;

    iNextFocusedControl = NULL;

    if (iAppName)

    {

        delete iAppName;

        iAppName = NULL;

    }

    if (iBrowserGarbage)

    {

        iBrowserGarbage->Control()->Destroy();

        iBrowserEngineLib.Close();

    }

    if (iBrowserShellGarbage)

    {

        iBrowserShellGarbage->Control()->Destroy();

    }

}

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

// CSwtUiUtils::RegisterShellL

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

//

void CSwtUiUtils::RegisterShellL(MSwtShell& aShell)

{

    ASSERT(iShells.Find(&aShell) == KErrNotFound);

    ASSERT(!CanBeActive(aShell));     // strict check

    User::LeaveIfError(iShells.Append(&aShell));

    aShell.Control()->HideSilently();

}

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

// CSwtUiUtils::UnregisterShell

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

//

void CSwtUiUtils::UnregisterShell(MSwtShell& aShell)

{

    TInt index = iShells.Find(&aShell);

    if (index == KErrNotFound)

    {

        return;

    }

    iShells.Remove(index);

    // If the application has focus and the unregistered shell was

    // active, find a new active shell. If the application is out of

    // focus, and this was the next shell to become active, clear it.

    // A new active shell will be searched when focus is gained.

    if (iFocusLost)

    {

        if (iNextActiveShell == &aShell)

        {

            iNextActiveShell = NULL;

        }

    }

    else

    {

        if (iActiveShell == &aShell)

        {

            SetShellFade(iActiveShell, EFalse);

            iActiveShell = NULL;

            FindAndActivateShell();

        }

    }

}

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

// CSwtUiUtils::SetActiveShell

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

//

TBool CSwtUiUtils::SetActiveShell(MSwtShell& aShell, TBool aSetFocus)

{

    if (iActiveShell == &aShell)

    {

        return ETrue;

    }

    if (CanBeActive(aShell))     // strict check

    {

        if (iFocusLost)

        {

            // Application out of focus, remember the next active shell.

            iNextActiveShell = &aShell;

            return EFalse;

        }

        else

        {

            // Application in focus, let the shell be active.

            DoSetActiveShell(aShell, aSetFocus);

            return ETrue;

        }

    }

    return EFalse;

}

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

// CSwtUiUtils::CanBeActive

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

//

TBool CSwtUiUtils::CanBeActive(MSwtShell& aShell, TBool aStrictCheck /*=ETrue*/) const

{

    MSwtControl& ctrl = *aShell.Control();

    // Must not have the NO_TRIM style (see 11.4.11 of Steve Northover's book on SWT)

    if (ctrl.Style() & KSwtStyleNoTrim)

    {

        return EFalse;

    }

    // Must be visible and enabled

    CCoeControl& coeCtrl = ctrl.CoeControl();

    if (!coeCtrl.IsVisible() || coeCtrl.IsDimmed())

    {

        return EFalse;

    }

    // If the new shell is modal or the parent of the new shell is the current

    // active modal shell then the new shell can still become active

    if (aStrictCheck && iActiveShell && IsApplicationModal(*iActiveShell))

    {

        if (!IsApplicationModal(aShell))

        {

            if (!aShell.Control()->IsDescentOf(*iActiveShell->Control()))

            {

                return EFalse;

            }

        }

    }

    // Same as above, while in background

    if (iFocusLost && aStrictCheck && iNextActiveShell && IsApplicationModal(*iNextActiveShell))

    {

        if (!IsApplicationModal(aShell))

        {

            if (!aShell.Control()->IsDescentOf(*iNextActiveShell->Control()))

            {

                return EFalse;

            }

        }

    }

    return ETrue;

}

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

// CSwtUiUtils::CanBeTopMost

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

//

TBool CSwtUiUtils::CanBeTopMost(MSwtShell& aShell) const

{

    MSwtControl& ctrl = *aShell.Control();

    // Must be visible and enabled

    CCoeControl& coeCtrl = ctrl.CoeControl();

    if (!coeCtrl.IsVisible())

    {

        return EFalse;

    }

    return ETrue;

}

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

// CSwtUiUtils::ShellActivabilityChanged

// Called from CSwtShell::MakeVisible and CSwtShell::SetDimmed

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

//

void CSwtUiUtils::ShellActivabilityChanged(MSwtShell& aShell)

{

    // Use the next active shell during no focus.

    MSwtShell* activeShell = NULL;

    if (iFocusLost)

    {

        activeShell = iNextActiveShell;

    }

    else

    {

        activeShell = iActiveShell;

    }

    // 1. Activate Shell

    // The new shell can become active if no shell was previously active

    // or if it is modal. This, only when setVisible() or setEnabled()

    // is called. If setActive() is called and the shell can become

    // active it will be set active anyway.

    if (CanBeActive(aShell))     // strict check

    {

        if (activeShell == &aShell)

        {

            return;

        }

        if (!activeShell || IsApplicationModal(aShell))

        {

            if (iFocusLost)

            {

                iNextActiveShell = &aShell;

            }

            else

            {

                DoSetActiveShell(aShell, ETrue);

            }

            return;

        }

    }

    // 2. Show Shell if it is a parent or a child of the currently active shell

    if (activeShell && activeShell != &aShell && aShell.Control()->CoeControl().IsVisible())

    {

        if (activeShell->Control()->IsDescentOf(*aShell.Control()))

        {

            // The active shell is a child of aShell

            MoveToEndOfQueue(aShell);

            MoveToEndOfQueue(*activeShell);

            aShell.Control()->ShowSilently();

            if (!aShell.GetParentShell() && iLastTopMostShell && iLastTopMostShell != &aShell)

            {

                iLastTopMostShell->Control()->HideSilently();

                // No need to remember the top most Shell till next activity change

                iLastTopMostShell = NULL;

            }

            TRAP_IGNORE(UpdateStatusPaneL());

            return;

        }

        if (aShell.Control()->IsDescentOf(*activeShell->Control()))

        {

            // The active shell is parent of aShell

            // The queue sorting is not important for child Shells.

            aShell.Control()->ShowSilently();

            return;

        }

    }

    // 3. Pick new active Shell if the active shell cannot be active anymore.

    // If the application is out of focus, let another shell become active

    // when focus is regained, otherwise deactivate and find new shell.

    if (activeShell == &aShell)

    {

        if (iFocusLost)

        {

            iNextActiveShell = NULL;

        }

        else

        {

            // Ancestors have priority in becoming active

            MSwtShell* parent = activeShell->GetParentShell();

            while (parent)

            {

                if (CanBeActive(*parent, EFalse))     // loose check

                {

                    DoSetActiveShell(*parent, ETrue);

                    break;

                }

                parent = parent->GetParentShell();

            }

            if (!parent)

            {

                if (!FindAndActivateShell())

                {

                    // Lost the last activateable Shell.

                    activeShell->ActivityChanged(EFalse, ETrue);

                    SetShellFade(activeShell, EFalse);

                    iActiveShell = NULL;

                    TRAP_IGNORE(UpdateStatusPaneL());

                }

            }

        }

    }

    // 4. Top Shells loosing ability of being topmost

    if (iLastTopMostShell && iLastTopMostShell == &aShell && !CanBeTopMost(aShell))

    {

        iLastTopMostShell = NULL;

        TRAP_IGNORE(UpdateStatusPaneL());

    }

}

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

// CSwtUiUtils::SetNextFocusedControl

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

//

void CSwtUiUtils::SetNextFocusedControl(MSwtControl* aNextFocusedControl)

{

    iNextFocusedControl = aNextFocusedControl;

}

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

// CSwtUiUtils::NextFocusedControl

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

//

MSwtControl* CSwtUiUtils::NextFocusedControl()

{

    return iNextFocusedControl;

}

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

// CSwtUiUtils::ChangeAppFocus

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

//

void CSwtUiUtils::ChangeAppFocus(MSwtShell& aShell, TBool aForeground)

{

    CCoeEnv* coeEnv = iDisplay.CoeEnv();

    TApaTask task(coeEnv->WsSession());

    task.SetWgId(coeEnv->RootWin().Identifier());

    if (aForeground)

    {

        iNextActiveShell = &aShell;

        task.BringToForeground();

    }

    else

    {

        task.SendToBackground();

    }

}

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

// CSwtUiUtils::BrowserDllEntry

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

//

TLibraryFunction CSwtUiUtils::BrowserDllEntryL()

{

    if (iBrowserDllEntry != NULL)

    {

        return iBrowserDllEntry;

    }

    if (KErrNone != iBrowserEngineLib.Load(_L("BrowserEngine.dll")))

    {

        User::Leave(KErrNoMemory);

    }

#ifdef __WINS__

    iBrowserDllEntry = iBrowserEngineLib.Lookup(10);

#else

    iBrowserDllEntry = iBrowserEngineLib.Lookup(1);

#endif

    return iBrowserDllEntry;

}

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

// CSwtUiUtils::ActiveBrowserCount

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

//

TInt CSwtUiUtils::ActiveBrowserCount() const

{

    return iCurrentBrowserCount;

}

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

// CSwtUiUtils::RegisterBrowser

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

//

void CSwtUiUtils::NotifyNewBrowserCreated()

{

    if (iBrowserGarbage)

    {

        iBrowserGarbage->Control()->Destroy();

        iBrowserGarbage = NULL;

        if (iShellGarbageCollectionRequested && iBrowserShellGarbage)

        {

            // There was request to destroy previous browser's shell,

            // so we destroy it now, when browser is gone

            iBrowserShellGarbage->Control()->Destroy();

            iShellGarbageCollectionRequested = EFalse;

            iBrowserShellGarbage = NULL;

        }

        else

        {

            // Old garbage shell was not requested to destroy, so there

            // will be new garbage when current browser is being destroyed.

            iBrowserShellGarbage = NULL;

        }

    }

    iCurrentBrowserCount++;

}

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

// CSwtUiUtils::GarbageCollect

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

//

void CSwtUiUtils::GarbageCollect(MSwtBrowser& aBrowser)

{

    if (!iBrowserGarbage)

    {

        // Collect browser

        iBrowserGarbage = &aBrowser;

        iBrowserShellGarbage = &aBrowser.Control()->GetShell();

        iShellGarbageCollectionRequested = EFalse;

    }

    iCurrentBrowserCount--;

}

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

// CSwtUiUtils::GarbageCollect

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

//

void CSwtUiUtils::GarbageCollect(MSwtShell& aShell)

{

    if (&aShell != iBrowserShellGarbage)

    {

        aShell.Control()->Destroy();

    }

    else

    {

        aShell.Control()->CoeControl().MakeVisible(EFalse);

        iShellGarbageCollectionRequested = ETrue;

    }

}

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

// CSwtUiUtils::CSwtUiUtils

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

//

CSwtUiUtils::CSwtUiUtils(MSwtDisplay& aDisplay)

        : iDisplay(aDisplay)

        , iFocusLost(EFalse)

        , iCurrentBrowserCount(0)

        , iBrowserGarbage(NULL)

        , iBrowserShellGarbage(NULL)

        , iShellGarbageCollectionRequested(EFalse)

        , iScrollBarBreadth(-1)

{

}

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

// CSwtUiUtils::ConstructL

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

//

void CSwtUiUtils::ConstructL()

{

    CEikonEnv& eikEnv = *iDisplay.CoeEnv();

    MEikAppUiFactory& appUiFactory = *(eikEnv.AppUiFactory());

    CEikAppUi& appUi = *(eikEnv.EikAppUi());

    // Set the status pane

    iStatusPane = appUiFactory.StatusPane();

    ASSERT(iStatusPane);

    iStatusPane->SetObserver(NULL);

    iStatusPane->MakeVisible(EFalse);

    iStatusPane->SetObserver(this);

    // Override window priorities. See TSwtWinPriority.

    // These traps cannot be packed into a single one since

    // we do not know which status pane controls exist.

    CCoeControl* ctrl = NULL;

    RDrawableWindow* win = NULL;

    // Context pane priority (image).