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

 * 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 <AknDef.h>

#include <AknsBasicBackgroundControlContext.h>

#include <swtlaffacade.h>

#ifdef RD_JAVA_S60_RELEASE_9_2

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#endif // RD_JAVA_S60_RELEASE_9_2

#include <coreuiavkoneswt.h>

#include "eswtmobileextensions.h"

#include "swtuiutils.h"

#include "swtshell.h"

// Main pane varieties

static const TInt KSwtMainPainVarietyClassic = 3;

static const TInt KSwtMainPainVarietySmallSpLandscape = 9;

static const TInt KSwtMainPainVarietySmallSpLandscapePen = 4;

#ifdef RD_JAVA_S60_RELEASE_9_2

static const TInt KSwtRoundCornerBgColorDiff = 50;

#endif // RD_JAVA_S60_RELEASE_9_2

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

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

// CSwtShell::NewL

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

//

CSwtShell* CSwtShell::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                           MSwtShell* aParent, TInt aStyle)

{

    CSwtShell* self = new(ELeave) CSwtShell(aDisplay, aPeer,

                                            aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtShell::CSwtShell

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

//

CSwtShell::CSwtShell(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                     MSwtShell* aParent, TInt aStyle)

        : CSwtDecorations(aDisplay, aPeer,

                          aParent ? aParent->Composite() : NULL, aStyle, EFalse, EFalse)

        , iMinSize(-1, -1)

        , iSavedStyle(aStyle)

        , iHasCba(aParent == NULL)

{

    SetFocusing(EFalse);

    // Top-level Shells are considered as always maximised

    if (!iParent)

    {

        iIsMaximized = ETrue;

    }

}

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

// CSwtShell::~CSwtShell

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

//

CSwtShell::~CSwtShell()

{

    // Do all the destruction in DoDelete().

}

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

// CSwtShell::ConstructL

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

//

void CSwtShell::ConstructL()

{

    // Create the window

    //

    // When created, the window does not inherit the control's visibility.

    // The workaround is to make the control visible, create the window and

    // finally make the control invisible again.

    // WARNING! Avkon expects window owning parent control to be always ready

    // to draw! See CCoeControl::DrawNow(). This might cause various problems!

    CCoeControl::MakeVisible(ETrue);

    CreateWindowL();

    CCoeControl::MakeVisible(EFalse);

    // Shells are by default invisible

    iCtrlFlags |= MSwtControl::EFlagInvisible;

    // Essential for clearing up tactile feedback when Button gets invisible.

    SetMopParent(iEikonEnv->EikAppUi());

    // The rect must be in window coordinates, not screen

    CSwtDecorations::ConstructL();

    // Set priority based on the shell style. See TSwtWinPriority.

    // 0 ordinal position means highest z position.

    TInt ordinalPos(1);

    if (!iParent)

    {

        ordinalPos = 0;

    }

    RWindow& window = Window();

    if (iStyle & KSwtStyleOnTop)

    {

        iWindowPriority = ESwtWinPriorityDefault;

    }

    else

    {

        iWindowPriority = ESwtWinPriorityShell;

    }

    window.SetOrdinalPosition(ordinalPos, iWindowPriority);

#ifdef RD_SCALABLE_UI_V2

    window.SetPointerGrab(ETrue);

#endif //RD_SCALABLE_UI_V2

    DoSetRect(DefaultBounds());

    SetMinimumSize(TSize());

    UiUtils().RegisterShellL(*this);

#ifdef RD_SCALABLE_UI_V2

    if ((iStyle & KSwtStyleSystemModal) != 0 ||

            (iStyle & KSwtStyleApplicationModal) != 0)

    {

        CCoeControl::SetGloballyCapturing(ETrue);

        CCoeControl::SetPointerCapture(ETrue);

    }

#endif //RD_SCALABLE_UI_V2

#ifdef RD_JAVA_S60_RELEASE_9_2

    GfxTransEffect::Enable();

    GfxTransEffect::Register(this,

                             iParent ? KGfxOptionsMenuControlUid : KGfxInformationNoteControlUid, EFalse);

    // Window transparency cannot be enabled as it breaks the async drawing.

    // Since transparency cannot be enabled, set the initial background

    // color to something closer to the theme's background.

    if (iParent)

    {

        TRgb bgColor = iDisplay.UiUtils().GetSystemColor(ESwtColorWidgetBackground);

        TInt r = bgColor.Green();

        r -= KSwtRoundCornerBgColorDiff;

        if (r < 0)

            r = 0;

        TInt g = bgColor.Green();

        g -= KSwtRoundCornerBgColorDiff;

        if (g < 0)

            g = 0;

        TInt b = bgColor.Blue();

        b -= KSwtRoundCornerBgColorDiff;

        if (b < 0)

            b = 0;

        bgColor.SetRed(b);

        bgColor.SetGreen(b);

        bgColor.SetBlue(b);

        OverrideColorL(EColorControlBackground, bgColor);

    }

#endif // RD_JAVA_S60_RELEASE_9_2

}

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

// CSwtShell::GetTopShell

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

//

MSwtShell& CSwtShell::GetTopShell() const

{

    return UiUtils().GetControlTopShell(*this);

}

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

// CSwtShell::RemoveAndRememberFocus

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

//

void CSwtShell::RemoveAndRememberFocus()

{

    ASSERT(iFocusControl && iFocusControl->CoeControl().IsFocused());

    ASSERT(!iFocusMemory);

    iFocusMemory = iFocusControl;

    // This sets iFocusControl to NULL

    iFocusControl->CoeControl().SetFocus(EFalse);

    ASSERT(!iFocusControl);

}

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

// CSwtShell::DoSetRect

// Note that calling SetRect on the Shell does not cause a PositionChanged!

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

//

void CSwtShell::DoSetRect(const TRect& aRect)

{

    // Divert the job to UiUtils if this is the Shell of an editor open for

    // split view editing.

    MSwtUiUtils& utils = iDisplay.UiUtils();

    MSwtControl* splitInputView = utils.SplitInputView();

    if (splitInputView && (&(splitInputView->GetShell())) == this)

    {

        utils.SetSplitInputShellPos(aRect.iTl);

        CCoeControl::SetSize(aRect.Size());

    }

    else

    {

        CCoeControl::SetRect(aRect);

    }

}

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

// CSwtShell::SwtHandleResourceChangeL

// From CSwtComposite

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

//

void CSwtShell::SwtHandleResourceChangeL(TInt aType)

{

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        if (!iParent)

        {

            CAknsBasicBackgroundControlContext* bg =

                static_cast<CAknsBasicBackgroundControlContext*>(GetControlContext());

            if (bg)

            {

                bg->SetRect(iDisplay.Device().Bounds());

            }

            DoSetRect(DefaultBounds());

        }

    }

    CSwtDecorations::SwtHandleResourceChangeL(aType);

}

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

// CSwtShell::CSwtShell

// From ASwtControlBase

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

//

void CSwtShell::DoPaint(const TRect& aRect) const

{

    // Set Draw called by eSWT drawing framework flag

    const_cast<CSwtShell *>(this)->iDrawCalledByOurFrwk = ETrue;

    // Restore title visibility so that it is drawn. See Draw method

    if (AsyncPainting())

    {

        if (iTitle)

        {

            iTitle->MakeVisible(this->IsVisible());

        }

    }

    CoeControl().DrawBackground(aRect);

    CSwtComposite::Draw(aRect);

    // Additional drawing code is to be added here instead of Draw()

    // Unset Draw called by eSWT drawing framework flag

    const_cast<CSwtShell *>(this)->iDrawCalledByOurFrwk = EFalse;

}

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

// CSwtShell::BorderInnerRect

// From ASwtControlBase

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

//

TRect CSwtShell::BorderInnerRect() const

{

    if (!iParent)

    {

        return CSwtComposite::BorderInnerRect();

    }

    else

    {

        return CSwtDecorations::BorderInnerRect();

    }

}

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

// CSwtShell::BorderOuterRect

// From ASwtControlBase

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

//

TRect CSwtShell::BorderOuterRect(const TRect& aRect) const

{

    if (!iParent)

    {

        return CSwtComposite::BorderOuterRect(aRect);

    }

    else

    {

        return CSwtDecorations::BorderOuterRect(aRect);

    }

}

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

// CSwtShell::DoDelete

// From ASwtControlBase

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

//

void CSwtShell::DoDelete()

{

#ifdef RD_JAVA_S60_RELEASE_9_2

    GfxTransEffect::Deregister(this);

#endif // RD_JAVA_S60_RELEASE_9_2

    CSwtUiUtils& uiUtils = UiUtils();

    if (uiUtils.GetActiveShell() == this)

    {

        iDisplay.MenuArranger().ActiveShellLost();

        // Notify Command arranger

        MSwtCommandArranger* commandArranger = iDisplay.CommandArranger();

        // commandArranger may be null as Mobile Extensions is optional

        if (commandArranger)

        {

            commandArranger->ActiveShellLost();

        }

    }

    uiUtils.UnregisterShell(*this);

    iFullTabList.Close();

    delete iTitleText;

    iTitleText = NULL;

    iFocusControl = NULL;

    iFocusMemory = NULL;

    iDefaultCommand = NULL;

    iControlGoingToStack= NULL;

    iControlGainingFocus= NULL;

    iTitleText = NULL;

    // Last step must always be this!

    UiUtils().GarbageCollect(*this);

}

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

// CSwtShell::OfferKeyEventL

// From CCoeControl

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

//

TKeyResponse CSwtShell::OfferKeyEventL(const TKeyEvent& aKeyEvent,

                                       TEventCode aType)

{

    // Offer key event to command arranger first

    TKeyResponse keyResponse = OfferKeyEventToCommandAndMenuArrangersL(aKeyEvent, aType);

    if (keyResponse != EKeyWasConsumed)

    {

        // Now to the tab group.

        // Tab groups are usually handled in HandleHeyL but this call

        // is needed for cases where there are no focusable controls

        keyResponse = OfferKeyEventToTabGroupL(aKeyEvent, aType);

    }

    if (keyResponse == EKeyWasConsumed)

    {

        return EKeyWasConsumed;

    }

    return CSwtDecorations::OfferKeyEventL(aKeyEvent, aType);

}

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

// CSwtShell::HandlePointerEventL

// This is the entry point for all pointer events targeted at any of the children

// of this Shell except for Browser's case.

// From CCoeControl

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

//

#ifdef RD_SCALABLE_UI_V2

void CSwtShell::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    CSwtUiUtils& utils = UiUtils();

    if (aPointerEvent.iType == TPointerEvent::EButton1Down)

    {

        utils.SetNaviKeyInput(EFalse);

        // Ignore pointer events outside modal Shells.

        MSwtShell *activeShell = utils.GetActiveShell();

        if (!activeShell || (activeShell && activeShell != this &&

                             !((activeShell->Control()->Style() & KSwtStylePrimaryModal) != 0

                               && activeShell->Control()->IsDescentOf(*this))))

        {

            utils.SetActiveShell(*this, ETrue);

        }

    }

    MSwtControl* capturingControl = utils.PointerCaptureControl();

    if (capturingControl && capturingControl != this)

    {

        if (aPointerEvent.iType == TPointerEvent::EButton1Down

                && capturingControl->IsFocusable())

        {

            capturingControl->SetSwtFocus(KSwtFocusByPointer);

        }

        capturingControl->HandlePointerEventL(aPointerEvent);

        iDisplay.TryDetectLongTapL(aPointerEvent);

        return;

    }

    if (!iDisplay.RevertPointerEvent())

    {

        CSwtComposite::HandlePointerEventL(aPointerEvent);

    }

    iDisplay.TryDetectLongTapL(aPointerEvent);

}

#else

void CSwtShell::HandlePointerEventL(const TPointerEvent& /*aPointerEvent*/)

{

}

#endif //RD_SCALABLE_UI_V2

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

// CSwtShell::MakeVisible

// From CCoeControl

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

//

void CSwtShell::MakeVisible(TBool aVisible)

{

    // Remove focus from its owner before making it invisible

    if (!aVisible && iFocusControl)

    {

        RemoveAndRememberFocus();

    }

    if (aVisible && !iBgContext)

    {

        TRAP_IGNORE(CreateBackgroundL());

    }

    CSwtUiUtils& utils = UiUtils();

#ifdef RD_JAVA_S60_RELEASE_9_2

    TBool doEffect = (IsVisible() != aVisible) && (iDisplay.IsUiReady() || iParent);

    if (doEffect)

    {

        GfxTransEffect::Begin(this, aVisible ? KGfxControlAppearAction : KGfxControlDisappearAction);

        GfxTransEffect::SetDemarcation(this, Rect());

    }

#endif // RD_JAVA_S60_RELEASE_9_2

    CSwtDecorations::MakeVisible(aVisible);

#ifdef RD_JAVA_S60_RELEASE_9_2

    if (doEffect)

    {

        GfxTransEffect::End(this);

    }

#endif // RD_JAVA_S60_RELEASE_9_2

    utils.ShellActivabilityChanged(*this);

    // Done already if the Shell became active

    if (aVisible && utils.GetActiveShell() != this)

    {

        if (!iFullScreen && HasCba())

        {

            utils.SetCbaVisible(ETrue);

        }

    }

}

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

// CSwtShell::SetDimmed

// From CCoeControl

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

//

void CSwtShell::SetDimmed(TBool aDimmed)

{

    CSwtDecorations::SetDimmed(aDimmed);

    UiUtils().ShellActivabilityChanged(*this);

}

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

// CSwtShell::FocusChanged

// From CCoeControl

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

//

void CSwtShell::FocusChanged(TDrawNow /*aDrawNow*/)

{

    // Shells cannot gain ( nor lose ) focus, they can only be active but we may

    // still end up here because of the app UI's AddToStackL().

    if (IsFocused())

    {

        CCoeControl::SetFocus(EFalse);

        if (iControlGoingToStack)

        {

            // This control child is added to control stack,

            // the Symbian framework will manages its focus.

            // When the SWT application goes to background,

            // Symbian will unfocus the control child.

            // The SWT application still runs,

            // and the fact that the control child is unfocused could perhaps

            // cause some conflicts in this SWT native implementation.

            TRAP_IGNORE(iControlGoingToStack->AddToControlStackL(

                            ECoeStackPriorityDefault));

        }

        if (iControlGainingFocus)

        {

            iControlGainingFocus->SetSwtFocus();

            iControlGainingFocus = NULL;