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

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

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <swtlaffacade.h>

#include "swtcontrolhelper.h"

#include "swtfont.h"

#include "swtcomposite.h"

#include "swtcaptionedcontrol.h"

// Default preferred size for an empty CaptionedControl

const TInt KSwtCaptionedCtrlDefPrefSize = 50;

const TInt KSwtDefaultCaptionMargin = 3;

const TInt KSwtDefaultTrailMargin = 3;

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

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

// CSwtCaptionedControl::CControlProxy::CountComponentControls

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

//

TInt CSwtCaptionedControl::CControlProxy::CountComponentControls() const

{

    return iChild ? 1 : 0;

}

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

// CSwtCaptionedControl::CControlProxy::ComponentControl

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

//

CCoeControl* CSwtCaptionedControl::CControlProxy::ComponentControl(

    TInt /*aIndex*/) const

{

    ASSERT(iChild);

    return &(iChild->CoeControl());

}

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

// CSwtCaptionedControl::CControlProxy::MinimumSize

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

//

TSize CSwtCaptionedControl::CControlProxy::MinimumSize()

{

    TSize size(0, 0);

    if (iChild)

    {

        // Use the computed size from the Java side. This way cover also

        // those components that compute their size on the Java side.

        size = iPreferredSize;

    }

    return size;

}

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

// CSwtCaptionedControl::CControlProxy::PositionChanged

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

//

void CSwtCaptionedControl::CControlProxy::PositionChanged()

{

    iPrevPos = iPosition;

}

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

// CSwtCaptionedControl::CControlProxy::SizeChanged

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

//

void CSwtCaptionedControl::CControlProxy::SizeChanged()

{

    if (iPosition != iPrevPos)

    {

        if (iChild)

        {

            iChild->CoeControl().SetPosition(iPosition);

        }

        iPrevPos = iPosition;

    }

    if (iChild)

    {

        iChild->CoeControl().SetSize(iSize);

    }

}

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

// CSwtCaptionedControl::NewL

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

//

CSwtCaptionedControl* CSwtCaptionedControl::NewL(MSwtDisplay& aDisplay,

        TSwtPeer aPeer, MSwtComposite& aParent, TInt aStyle)

{

    CSwtCaptionedControl* self = new(ELeave) CSwtCaptionedControl(aDisplay,

            aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtCaptionedControl::CSwtCaptionedControl

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

//

CSwtCaptionedControl::CSwtCaptionedControl(MSwtDisplay& aDisplay,

        TSwtPeer aPeer, MSwtComposite& aParent, TInt aStyle)

        : ASwtControlBase(aDisplay, aPeer, &aParent, aStyle)

{

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

    CEikCaptionedControl::MakeVisible(coeParent.IsVisible());

    CEikCaptionedControl::SetDimmed(coeParent.IsDimmed());

    SetComponentsToInheritVisibility(ETrue);

    SetFocusing(ETrue);

}

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

// CSwtCaptionedControl::~CSwtCaptionedControl

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

//

CSwtCaptionedControl::~CSwtCaptionedControl()

{

    // Own

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

    iChildren.Close();

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    // Not Own

    iForegroundColor = NULL;

}

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

// CSwtCaptionedControl::ConstructL

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

//

void CSwtCaptionedControl::ConstructL()

{

    SetContainerWindowL(GetParent()->Control()->CoeControl());

    // Workaround - We need to set that now, so as the

    // ConstructExtensionL is called inside the CaptionnedControl.

    SetEditableL(EFalse);

    // Retrieve default font

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(), iDisplay.Device().GetSystemFont()->Font());

    iControl = new(ELeave) CControlProxy;

    iControl->SetComponentsToInheritVisibility(ETrue);

    iControl->SetContainerWindowL(*this); // Absolutely necessary

    iControl->SetMopParent(this); // Absolutely necessary

    iControl->SetFocusing(ETrue);

    iControl->ActivateL();

    SetDefaultForegroundL();

    SetBackground(this);    // Back will be drawn by ASwtControlBase::Draw

    ActivateL();

}

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

// CSwtCaptionedControl::Child

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

//

inline const MSwtControl* CSwtCaptionedControl::Child() const

{

    ASSERT(iControl);

    return static_cast<CControlProxy*>(iControl)->iChild;

}

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

// CSwtCaptionedControl::Child

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

//

inline MSwtControl* CSwtCaptionedControl::Child()

{

    ASSERT(iControl);

    return static_cast<CControlProxy*>(iControl)->iChild;

}

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

// CSwtCaptionedControl::CoeChild

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

//

inline const CCoeControl* CSwtCaptionedControl::CoeChild() const

{

    const MSwtControl* child = Child();

    return (child) ? &child->CoeControl() : NULL;

}

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

// CSwtCaptionedControl::CoeChild

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

//

inline CCoeControl* CSwtCaptionedControl::CoeChild()

{

    MSwtControl* child = Child();

    return (child) ? &child->CoeControl() : NULL;

}

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

// CSwtCaptionedControl::SetChild

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

//

inline void CSwtCaptionedControl::SetChild(MSwtControl* aChild)

{

    ASSERT(iControl);

    static_cast<CControlProxy*>(iControl)->iChild = aChild;

}

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

// CSwtCaptionedControl::SetEmphasis

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

//

void CSwtCaptionedControl::SetEmphasis(TDrawNow /*aDrawNow*/)

{

    // If foreground color has not been set then update according to focus

    if (!iForegroundColor)

    {

        TRAP_IGNORE(SetDefaultForegroundL());

    }

    Redraw();

}

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

// CSwtCaptionedControl::ComputeInnerRect

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

//

TRect CSwtCaptionedControl::ComputeInnerRect(const TRect& aRect) const

{

    TRect borderInnerRect(aRect);

    TRect innerRect(aRect);

    // Compute rect inside borders

    TInt borderWidth = GetBorderWidth();

    borderInnerRect.Shrink(borderWidth, borderWidth);

    // Compute rect inside frame

    innerRect.iTl = CSwtLafFacade::GetLayoutRect(

                        CSwtLafFacade::EInputFieldSkinPlacingGeneralLine2, aRect).Rect().iBr;

    innerRect.iBr = CSwtLafFacade::GetLayoutRect(

                        CSwtLafFacade::EInputFieldSkinPlacingGeneralLine5, aRect).Rect().iTl;

    // Merge computed rects

    if (innerRect.iTl.iX < borderInnerRect.iTl.iX)

    {

        innerRect.iTl.iX = borderInnerRect.iTl.iX;

    }

    if (innerRect.iTl.iY < borderInnerRect.iTl.iY)

    {

        innerRect.iTl.iY = borderInnerRect.iTl.iY;

    }

    if (innerRect.iBr.iX > borderInnerRect.iBr.iX)

    {

        innerRect.iBr.iX = borderInnerRect.iBr.iX;

    }

    if (innerRect.iBr.iY > borderInnerRect.iBr.iY)

    {

        innerRect.iBr.iY = borderInnerRect.iBr.iY;

    }

    innerRect.Normalize();

    return innerRect;

}

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

// CSwtCaptionedControl::DoSetSize

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

//

void CSwtCaptionedControl::DoSetSize(const TSize& aSize)

{

    // Compute new inner rect

    TRect newRect(Rect());

    newRect.SetSize(aSize);

    iInnerRect = ComputeInnerRect(newRect);

    // Give iInnerRect to CEikCaptionedControl SetSize

    TPoint realPosition(iPosition);

    iPosition = iInnerRect.iTl;

    // Save aSize before calling SetSize because it will modify iSize and aSize

    // may be a reference to iSize. In this case, aSize would be modified

    // whereas we want to use it as parameter of SetSizeWithoutNotification.

    TSize realSizeToSet(aSize);

    CEikCaptionedControl::SetSize(iInnerRect.Size());

    // Set our rect to its real value

    iPosition = realPosition;

    CEikCaptionedControl::SetSizeWithoutNotification(realSizeToSet);

}

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

// CSwtCaptionedControl::SetDefaultForegroundL

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

//

void CSwtCaptionedControl::SetDefaultForegroundL()

{

    TRgb defaultColor;

    TAknsQsnTextColorsIndex colorIndex;

    if (iDisplay.UiUtils().NaviKeyInput() && IsFocusedOrChildIsFocused())

    {

        colorIndex = EAknsCIQsnTextColorsCG10;

    }

    else

    {

        colorIndex = EAknsCIQsnTextColorsCG8;

    }

    if (AknsUtils::GetCachedColor(AknsUtils::SkinInstance(), defaultColor,

                                  KAknsIIDQsnTextColors, colorIndex) == KErrNone)

    {

        OverrideColorL(EColorLabelText, defaultColor);

    }

}

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

// CSwtCaptionedControl::GetRecursiveChildrenL

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

//

void CSwtCaptionedControl::GetRecursiveChildrenL(RSwtControlArray& aAllChildren,

        MSwtComposite& aParent)

{

    const RSwtControlArray* children = aParent.Children();

    if (children)

    {

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

        {

            MSwtControl* child = (*children)[i];

            ASSERT(child);

            User::LeaveIfError(aAllChildren.Append(child));

            MSwtComposite* composite = child->CompositeInterface();

            if (composite)

            {

                GetRecursiveChildrenL(aAllChildren, *composite);

            }

        }

    }

}

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

// CSwtCaptionedControl::RealFontHeight

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

//

TBool CSwtCaptionedControl::RealFontHeight(TInt& aHeight) const

{

    const MSwtFont* swtFont = GetFont();

    ASSERT(swtFont);

    const CFont& font = swtFont->Font();

    const CFbsFont* fbsFont = NULL;

    if (font.TypeUid() == KCFbsFontUid)

    {

        fbsFont = static_cast<const CFbsFont*>(&font);

    }

    if (fbsFont && fbsFont->IsOpenFont())

    {

        // font.AscentInPixels() and font.DescentInPixels() ( used by iCaption

        // and iTrailer ( CEikLabel ) ) don't include the height of accents etc.

        // Use the maximum possible ascent/decent instead.

        aHeight = font.FontMaxHeight();

        return ETrue;

    }

    else

    {

        return EFalse;

    }

}

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

// CSwtCaptionedControl::DefaultLeftMargin

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

//

TInt CSwtCaptionedControl::DefaultLeftMargin() const

{

#if 0

    TRect dummyRect(0, 0, KSwtCaptionedCtrlDefPrefSize,

                    KSwtCaptionedCtrlDefPrefSize);

    return CSwtLafFacade::GetLayoutText(

               CSwtLafFacade::EFormDataWideGraphicFieldTextsLine2, dummyRect).

           TextRect().iTl.iX;

#endif

    return 0;

}

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

// CSwtCaptionedControl::CountComponentControls

// From CCoeControl

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

//

TInt CSwtCaptionedControl::CountComponentControls() const

{

    // We don't want iControl to be counted as a component control

    CCoeControl* controls[] = { iBitmap, iCaption, iTrailer };

    TInt count = 0;

    TInt nrOfCtrls = sizeof(controls) / sizeof(CCoeControl*);

    for (TUint i = 0; i < nrOfCtrls; i++)

    {

        if (controls[i])

        {

            count++;

        }

    }

    return count;

}

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

// CSwtCaptionedControl::ComponentControl

// From CCoeControl

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

//

CCoeControl* CSwtCaptionedControl::ComponentControl(TInt aIndex) const

{

    // We don't want iControl to be counted as a component control

    CCoeControl* controls[] = { iBitmap, iCaption, iTrailer };

    TInt nrOfCtrls = sizeof(controls) / sizeof(CCoeControl*);

    for (TUint i = 0; i < nrOfCtrls; i++)

    {

        if (controls[i] && aIndex-- == 0)

        {

            return controls[i];

        }

    }

    return NULL;

}

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

// CSwtCaptionedControl::MakeVisible

// From CCoeControl

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

//

void CSwtCaptionedControl::MakeVisible(TBool aVisible)

{

    CEikCaptionedControl::MakeVisible(aVisible);

    MSwtControl* child = Child();

    // This prevents making visible controls invisible on their own

    if (child && !(child->Flags() & EFlagInvisible))

    {

        child->CoeControl().MakeVisible(aVisible);

    }

    FocusabilityChanged();

}

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

// CSwtCaptionedControl::SetDimmed

// From CCoeControl

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

//

void CSwtCaptionedControl::SetDimmed(TBool aDimmed)

{

    CEikCaptionedControl::SetDimmed(aDimmed);

    MSwtControl* child = Child();

    // This prevents undimming controls dimmed on their own

    if (child && !(child->Flags() & EFlagDisabled))

    {

        child->CoeControl().SetDimmed(aDimmed);

    }

    if (iCaption)

    {

        iCaption->SetDimmed(aDimmed);

    }

    if (iTrailer)

    {

        iTrailer->SetDimmed(aDimmed);

    }

    FocusabilityChanged();

}

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

// CSwtCaptionedControl::OfferKeyEventL

// From CCoeControl

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

//

TKeyResponse CSwtCaptionedControl::OfferKeyEventL(const TKeyEvent& aEvent,

        TEventCode aType)

{

    return HandleKeyL(aEvent, aType, ETrue);

}

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

// CSwtCaptionedControl::MinimumSize

// From CCoeControl

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

//

TSize CSwtCaptionedControl::MinimumSize()

{

    // Default left margin for caption and control

    TInt leftMargin = DefaultLeftMargin();

    // First line

    TSize firstLineSize(0, 0);

    // Bitmap

    if (iBitmap)

    {

        TSize bitmapSize(iBitmap->MinimumSize());

        firstLineSize = bitmapSize;

        firstLineSize.iHeight += KSwtDefaultCaptionMargin;

    }

    // Left margin

    if (firstLineSize.iWidth < leftMargin)

    {

        firstLineSize.iWidth = leftMargin;

    }

    // Caption

    if (iCaption && !(iCaption->Text()->Length()))

    {

        delete iCaption;

        iCaption = NULL;