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

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

#include <eikbtgpc.h>

#include <eikspane.h>

#include <gulicon.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <swtlaffacade.h>

#include "swtcontrolhelper.h"

#include "swtdecorations.h"

// Blank title string

_LIT(KEmptyTitle, " ");

// Space between title and contents in dialog shells.

static const TInt KSwtTitlePaneBottomMargin = 5;

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

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

// CSwtDecorations::ConstructL

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

//

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

                                       MSwtComposite& aParent, TInt aStyle)

{

    CCoeControl& parentCtrl = aParent.Control()->CoeControl();

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

            &aParent, aStyle, parentCtrl.IsVisible(), parentCtrl.IsDimmed());

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtDecorations::~CSwtDecorations

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

//

CSwtDecorations::~CSwtDecorations()

{

    delete iTitle;

    iTitle = NULL;

    delete iBgContext;

    iBgContext = NULL;

    delete iText;

    iText = NULL;

    if (iImage)

    {

        iImage->RemoveSubRef(iImageSize);

        iImage->RemoveRef();

        iImage = NULL;

    }

    iMenuBar = NULL;

    iDefaultButton = NULL;

    iFocusedDefaultButton = NULL;

}

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

// CSwtDecorations::BorderInnerRectWithoutTitle

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

//

TRect CSwtDecorations::BorderInnerRectWithoutTitle() const

{

    ASSERT(iParent);

    TRect borderInnerRect(Rect());

    if (HasBorderStyle())

    {

        TAknLayoutRect topLeft = CSwtLafFacade::GetLayoutRect(

                                     CSwtLafFacade::EPopupWindowsSkinPlacingFrameGeneralLine2,

                                     borderInnerRect, 0);

        TAknLayoutRect bottomRight = CSwtLafFacade::GetLayoutRect(

                                         CSwtLafFacade::EPopupWindowsSkinPlacingFrameGeneralLine5,

                                         borderInnerRect, 0);

        borderInnerRect.Move(topLeft.Rect().Width(),

                             topLeft.Rect().Height());

        borderInnerRect.Resize(-topLeft.Rect().Width(),

                               -topLeft.Rect().Height());

        borderInnerRect.Resize(-bottomRight.Rect().Width(),

                               -bottomRight.Rect().Height());

    }

    return borderInnerRect;

}

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

// CSwtDecorations::ConstructL

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

//

void CSwtDecorations::ConstructL()

{

    CSwtCanvas::ConstructL();

    CreateTitleL();

    iNormalBounds = GetBounds();

}

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

// CSwtDecorations::CreateTitleL

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

//

void CSwtDecorations::CreateTitleL()

{

    if (!iParent || !HasTitleStyle())

    {

        return;

    }

    ASSERT(!iTitle);

    iTitle = new(ELeave) CAknPopupHeadingPane();

    TPtrC extPtr(KEmptyTitle);

    iTitle->ConstructL(extPtr);

    iTitle->SetContainerWindowL(*this);

    iTitle->MakeVisible(EFalse);   // Needed for drawing trick

    UpdateFrameL();

}

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

// CSwtDecorations::CreateBackgroundL

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

//

void CSwtDecorations::CreateBackgroundL()

{

    ASSERT(!iBgContext);

    if (!iParent)

    {

        iBgContext = CAknsBasicBackgroundControlContext::NewL(

                         KAknsIIDQsnBgScreen, iDisplay.Device().Bounds(), ETrue);

    }

    else

    {

        iBgContext = CAknsFrameBackgroundControlContext::NewL(

                         KAknsIIDQsnFrPopup, Rect(), BorderInnerRectWithoutTitle(), ETrue);

        MAknsControlContext* topContext = GetTopShell().Control()->GetControlContext();

        if (topContext)

        {

            iBgContext->SetParentContext(topContext);

        }

        iBgContext->SetParentPos(PositionRelativeToScreen());

    }

}

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

// CSwtDecorations::UpdateTitleImageL

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

//

void CSwtDecorations::UpdateTitleImageL()

{

    if (!iTitle)

    {

        return;

    }

    if (!iImage)

    {

        iTitle->SetHeaderImageOwnedL(NULL);

        return;

    }

    TSize bitmapSize = SwtControlHelper::GetAspectRatioScaledBitmapSize(

                           iImage->Bitmap().SizeInPixels(),

                           CSwtLafFacade::GetLayoutRect(CSwtLafFacade::EChildShellTitleImagePane, iTitle->Rect()).Rect().Size());

    if (iImageSize == bitmapSize)

    {

        return;

    }

    CFbsBitmap* bitmap =  const_cast<CFbsBitmap*>(&iImage->SubBitmap(bitmapSize));

    CFbsBitmap* mask = const_cast<CFbsBitmap*>(iImage->SubMaskBitmap(bitmapSize, ETrue));

    if (iImageSize != TSize(-1, -1))

    {

        iImage->RemoveSubRef(iImageSize);

    }

    iImage->AddSubRef(bitmapSize);

    iImageSize = bitmapSize;

    CEikImage* image = new(ELeave) CEikImage();

    image->SetNewBitmaps(bitmap, mask);

    image->SetPictureOwnedExternally(ETrue);   // Bitmaps owned by CSwtImage

    iTitle->SetHeaderImageOwnedL(image);

}

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

// CSwtDecorations::SwtHandleResourceChangeL

// From CSwtComposite

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

//

void CSwtDecorations::SwtHandleResourceChangeL(TInt aType)

{

    CSwtCanvas::SwtHandleResourceChangeL(aType);

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        UpdateTitleImageL();

    }

}

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

// CSwtDecorations::DrawBorder

// From ASwtControlBase

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

//

void CSwtDecorations::DrawBorder(const TRect& /*aRect*/) const

{

    CWindowGc& gc = SystemGc();

    AknsDrawUtils::BackgroundBetweenRects(AknsUtils::SkinInstance(),

                                          iBgContext, this, gc, Rect(), BorderInnerRectWithoutTitle());

}

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

// CSwtDecorations::BorderInnerRect

// From ASwtControlBase

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

//

TRect CSwtDecorations::BorderInnerRect() const

{

    ASSERT(iParent);

    TRect innerRect(BorderInnerRectWithoutTitle());

    if (iTitle && HasTitleStyle())

    {

        innerRect.iTl.iY = iTitle->Rect().iBr.iY + KSwtTitlePaneBottomMargin;

    }

    return innerRect;

}

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

// CSwtDecorations::BorderOuterRect

// From ASwtControlBase

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

//

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

{

    ASSERT(iParent);

    TRect borderOuterRect(aRect);

    if (iTitle && HasTitleStyle())

    {

        borderOuterRect.iTl.iY -= iTitle->MinimumSize().iHeight;

    }

    if (HasBorderStyle())

    {

        TRect windowRect(Rect());

        TAknLayoutRect topLeft = CSwtLafFacade::GetLayoutRect(

                                     CSwtLafFacade::EPopupWindowsSkinPlacingFrameGeneralLine2,

                                     windowRect, 0);

        TAknLayoutRect bottomRight = CSwtLafFacade::GetLayoutRect(

                                         CSwtLafFacade::EPopupWindowsSkinPlacingFrameGeneralLine5,

                                         windowRect, 0);

        borderOuterRect.Move(-topLeft.Rect().Width(),

                             -topLeft.Rect().Height());

        borderOuterRect.Resize(topLeft.Rect().Width(),

                               topLeft.Rect().Height());

        borderOuterRect.Resize(bottomRight.Rect().Width(),

                               bottomRight.Rect().Height());

    }

    return borderOuterRect;

}

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

// CSwtDecorations::CountComponentControls

// From CCoeControl

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

//

TInt CSwtDecorations::CountComponentControls() const

{

    TInt count = CSwtCanvas::CountComponentControls();

    if (iParent && iTitle && HasTitleStyle())

    {

        ++count;

    }

    return count;

}

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

// CSwtDecorations::ComponentControl

// From CCoeControl

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

//

CCoeControl* CSwtDecorations::ComponentControl(TInt aIndex) const

{

    if (iParent && iTitle && HasTitleStyle())

    {

        if (aIndex == 0)

        {

            return iTitle;

        }

        --aIndex;

    }

    return CSwtCanvas::ComponentControl(aIndex);

}

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

// CSwtDecorations::SizeChanged

// From CCoeControl

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

//

void CSwtDecorations::SizeChanged()

{

    if (iParent && iTitle && HasTitleStyle())

    {

        //Can be called during ConstructL() before title is created... :-|

        LayoutTitle();

    }

    CSwtCanvas::SizeChanged();

    if (iParent && iBgContext)

    {

        // Update the Background Skin Size of Child Shell.

        // The size of the top level background doesn't need to be updated

        // because it used the display bounds. So we just update it on a

        // "HandleResourceChange" when the screen size change.

        (static_cast<CAknsFrameBackgroundControlContext*>(iBgContext))->SetFrameRects(

            Rect(), BorderInnerRectWithoutTitle());

    }

}

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

// CSwtDecorations::PositionChanged

// From CCoeControl

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

//

void CSwtDecorations::PositionChanged()

{

    if (iParent && iTitle && HasTitleStyle())

    {

        LayoutTitle();

    }

    CSwtComposite::PositionChanged();

    if (iParent && iBgContext)

    {

        iBgContext->SetParentPos(PositionRelativeToScreen());

    }

}

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

// CSwtDecorations::FocusChanged

// From CCoeControl

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

//

void CSwtDecorations::FocusChanged(TDrawNow aDrawNow)

{

    if (iParent && iTitle && HasTitleStyle())

    {

        TBool focused = IsFocused();

        iTitle->SetFocus(focused, ENoDrawNow);

        if (focused)

        {

            LayoutTitle();

        }

    }

    CSwtCanvas::FocusChanged(aDrawNow);

}

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

// CSwtDecorations::MopSupplyObject

// From CCoeControl

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

//

TTypeUid::Ptr CSwtDecorations::MopSupplyObject(TTypeUid aId)

{

    if (aId.iUid == CEikMenuBar:: ETypeId)

    {

        // The menu bar of the menu arranger is supplied for instance when

        // a Edwin asks for a menu bar to display its fep editing menu.

        return aId.MakePtr(iDisplay.MenuArranger().EikMenuBar());

    }

    if (aId.iUid == MAknsControlContext::ETypeId && iTitle)

    {

        return MAknsControlContext::SupplyMopObject(aId, GetControlContext());

    }

    return CSwtCanvas::MopSupplyObject(aId);

}

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

// CSwtDecorations::GetControlContext

// From MSwtControl

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

//

MAknsControlContext* CSwtDecorations::GetControlContext() const

{

    return iBgContext;

}

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

// CSwtDecorations::GetText

// From MSwtDecorations

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

//

const TDesC* CSwtDecorations::GetText() const

{

    ASSERT(iParent);

    return iText;

}

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

// CSwtDecorations::ConstructL

// From MSwtDecorations

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

//

void CSwtDecorations::SetTextL(const TDesC& aText)

{

    ASSERT(iParent);

    if (iText)

    {

        delete iText;

        iText = NULL;

    }

    iText = aText.AllocL();

    if (iTitle)

    {

        iTitle->SetTextL(aText);

    }

    if (iTitle)

    {

        RedrawRegion(iTitle->Rect());

    }

}

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

// CSwtDecorations::SetDefaultButton

// From MSwtDecorations

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

//

void CSwtDecorations::SetDefaultButton(MSwtButton* aButton)

{

    if (iDefaultButton == aButton)

    {

        return;

    }

    if (iDefaultButton)

    {

        MSwtControl* focusControl = GetShell().FocusControl();

        // If the current default button is the current focus control, it keeps

        // its default status. If the current focus control is not a button,

        // the current default button will be changed and should lose its

        // default status now. The case where there is no focus control could

        // probably not happen, but we even so remove the default status

        // of the current default button for secure.

        if (focusControl)

        {

            if (focusControl->ButtonInterface() != iDefaultButton)

            {

                const_cast<MSwtButton*>(iDefaultButton)->SetDefault(EFalse);

            }

        }

        else

        {

            const_cast<MSwtButton*>(iDefaultButton)->SetDefault(EFalse);

        }

    }

    iDefaultButton = aButton;

    if (iDefaultButton)

    {

        MSwtControl* focusControl = GetShell().FocusControl();

        if (focusControl)

        {

            // If the current focused control is not a Button

            // then the new current default button gain the default status.

            if (focusControl->ButtonInterface() == NULL)

            {

                const_cast<MSwtButton*>(iDefaultButton)->SetDefault(ETrue);

            }

            else if ((focusControl->Style() & KSwtStylePush) == 0)

            {

                const_cast<MSwtButton*>(iDefaultButton)->SetDefault(ETrue);

            }

        }

        else

        {

            const_cast<MSwtButton*>(iDefaultButton)->SetDefault(ETrue);

        }

    }

}

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

// CSwtDecorations::SetFocusedDefaultButton

// From MSwtDecorations

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

//

void CSwtDecorations::SetFocusedDefaultButton(MSwtButton* aButton)

{

    if (aButton)

    {

        ASSERT(aButton->Control()->Style() & KSwtStylePush);

        aButton->SetDefault(ETrue);

        // If the defaultButton of the CSwtDecorations is not the Focused Button,

        // so remove its DefaultButton Status.

        if ((iDefaultButton != aButton) && iDefaultButton)

        {

            iDefaultButton->SetDefault(EFalse);

        }

    }

    else

    {

        iFocusedDefaultButton->SetDefault(EFalse);

        // So set the DefaultButton status on the CSwtDecorations to DefaultButton.

        if (iDefaultButton)

        {

            iDefaultButton->SetDefault(ETrue);

        }

    }

    iFocusedDefaultButton = aButton;

}

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

// CSwtDecorations::OriginalDefaultButton

// From MSwtDecorations