/*******************************************************************************
 * 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 <AknUtils.h>
#include <eiksbfrm.h>
#include "swtscrollablebase.h"
#include "swtscrollbar.h"


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


TRect ASwtScrollableBase::SbInnerRect(const TRect& aOuterRect) const
{
    TRect innerRect(aOuterRect);
    CEikScrollBarFrame* sbFrame = SbFrame();

    if (sbFrame)
    {
        const CEikScrollBar* hsb = iHScroll ?
                                   &iHScroll->EikScrollBar() :
                                   sbFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal);
        if (hsb && hsb->IsVisible())
        {
            TInt height = iDisplay.UiUtils().ScrollBarBreadth(hsb);
            innerRect.iBr.iY = Max(innerRect.iBr.iY-height, innerRect.iTl.iY);
        }

        const CEikScrollBar* vsb = iVScroll ?
                                   &iVScroll->EikScrollBar() :
                                   sbFrame->GetScrollBarHandle(CEikScrollBar::EVertical);
        if (vsb && vsb->IsVisible())
        {
            TInt width = iDisplay.UiUtils().ScrollBarBreadth(vsb);
            if (AknLayoutUtils::LayoutMirrored())
            {
                innerRect.iTl.iX = Min(innerRect.iTl.iX+width, innerRect.iBr.iX);
            }
            else
            {
                innerRect.iBr.iX = Max(innerRect.iBr.iX-width, innerRect.iTl.iX);
            }
        }
    }

    return innerRect;
}

TRect ASwtScrollableBase::SbOuterRect(const TRect& aInnerRect) const
{
    TRect outerRect(aInnerRect);
    CEikScrollBarFrame* sbFrame = SbFrame();

    if (sbFrame)
    {
        const CEikScrollBar* hsb = iHScroll ?
                                   &iHScroll->EikScrollBar() :
                                   sbFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal);
        if (hsb && hsb->IsVisible())
        {
            TInt height = iDisplay.UiUtils().ScrollBarBreadth(hsb);
            outerRect.iBr.iY += height;
        }

        const CEikScrollBar* vsb = iVScroll ?
                                   &iVScroll->EikScrollBar() :
                                   sbFrame->GetScrollBarHandle(CEikScrollBar::EVertical);
        if (vsb && vsb->IsVisible())
        {
            TInt width = iDisplay.UiUtils().ScrollBarBreadth(vsb);
            if (AknLayoutUtils::LayoutMirrored())
            {
                outerRect.iTl.iX -= width;
            }
            else
            {
                outerRect.iBr.iX += width;
            }
        }
    }

    return outerRect;
}

// From MSwtScrollable
MSwtControl* ASwtScrollableBase::Control()
{
    return this;
}

// ASwtScrollableBase::CreateScrollBarL
MSwtScrollBar* ASwtScrollableBase::CreateScrollBarL(TSwtPeer aPeer, TInt aStyle)
{
    // Get frame
    CEikScrollBarFrame* sbFrame = SbFrame();
    if (!sbFrame)
    {
        return NULL;
    }

    // Asserts
    ASSERT(aStyle == KSwtStyleHScroll || aStyle == KSwtStyleVScroll);
    ASSERT((iStyle & aStyle) != 0);

    // Get scrollbar reference and orientation
    CEikScrollBar::TOrientation orientation;
    CSwtScrollBar** scrollbar;
    if (aStyle == KSwtStyleHScroll)
    {
        orientation = CEikScrollBar::EHorizontal;
        scrollbar = &iHScroll;
    }
    else
    {
        orientation = CEikScrollBar::EVertical;
        scrollbar = &iVScroll;
    }

    // Tile and return scrollbar
    TRect clientRect(Control()->ClientRect());
    TRect inclusiveRect(SbOuterRect(ClientRect()));
    TEikScrollBarModel hModel(DefaultSbModel(KSwtStyleHScroll));
    TEikScrollBarModel vModel(DefaultSbModel(KSwtStyleVScroll));
    TEikScrollBarFrameLayout layout;
    layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant;
    layout.SetClientMargin(0);
    layout.SetInclusiveMargin(0);

    // Cannot use non double span models for double span scrollbars! Avoiding panics.
    TBool doubleSpan = sbFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan;
    if (doubleSpan)
    {
        TAknDoubleSpanScrollBarModel hDsSbarModel(hModel);
        TAknDoubleSpanScrollBarModel vDsSbarModel(vModel);
        sbFrame->TileL(&hDsSbarModel, &vDsSbarModel, clientRect, inclusiveRect, layout);
    }
    else
    {
        sbFrame->TileL(&hModel, &vModel, clientRect, inclusiveRect, layout);
    }

    CEikScrollBar* sb = sbFrame->GetScrollBarHandle(orientation);
    if (sb)
    {
        *scrollbar = new(ELeave) CSwtScrollBar(iDisplay, aPeer, aStyle,
                                               *sb, *this, 0, CSwtLafFacade::KSwtDefaultScrollBarModelScrollSpan,
                                               CSwtLafFacade::KSwtDefaultScrollBarModelThumbposition,
                                               CSwtLafFacade::KSwtDefaultScrollBarModelThumbSpan, doubleSpan,
                                               orientation);
        sbFrame->SetScrollBarFrameObserver(this);
        return *scrollbar;
    }

    return NULL;
}

// From MSwtScrollable
void ASwtScrollableBase::SetVisibleScrollBar(TInt aStyle, TBool aVisible)
{
    // Get frame
    CEikScrollBarFrame* sbFrame = SbFrame();
    if (!sbFrame)
    {
        return;
    }

    // Get scrollbars visibility
    CEikScrollBarFrame::TScrollBarVisibility hVis =
        sbFrame->ScrollBarVisibility(CEikScrollBar::EHorizontal);
    CEikScrollBarFrame::TScrollBarVisibility vVis =
        sbFrame->ScrollBarVisibility(CEikScrollBar::EVertical);

    // Calculate new visibility states
    if (aStyle & KSwtStyleHScroll)
    {
        if (aVisible)
        {
            hVis = CEikScrollBarFrame::EOn;
        }
        else
        {
            hVis = CEikScrollBarFrame::EOff;
        }
        iHScroll->SetVisible(aVisible);
    }

    if (aStyle & KSwtStyleVScroll)
    {
        if (aVisible)
        {
            vVis = CEikScrollBarFrame::EOn;
        }
        else
        {
            vVis = CEikScrollBarFrame::EOff;
        }
        iVScroll->SetVisible(aVisible);
    }

    // Apply new visibility states
    TRAP_IGNORE(sbFrame->SetScrollBarVisibilityL(hVis, vVis));

    // Resize Scrollable, as the client area has changed
    CCoeControl& coeCtrl = CoeControl();
    coeCtrl.SetSize(coeCtrl.Size());

    // Force a redraw here as some Scrollables do not update the screen after
    // a scrollbar as been switched on or off.
    Redraw();
}

// From MSwtScrollable
void ASwtScrollableBase::ScrollBarDestroyed(const MSwtScrollBar* aScrollbar)
{
    // Get frame
    CEikScrollBarFrame* sbFrame = SbFrame();
    if (sbFrame == NULL)
    {
        return;
    }

    // Calculate new visibility states, clear scrollbar reference
    CEikScrollBarFrame::TScrollBarVisibility hVis;
    CEikScrollBarFrame::TScrollBarVisibility vVis;
    if (aScrollbar == iHScroll)
    {
        hVis = CEikScrollBarFrame::EOff;
        vVis = sbFrame->ScrollBarVisibility(CEikScrollBar::EVertical);
        iHScroll = NULL;
    }
    else
    {
        ASSERT(aScrollbar == iVScroll);
        hVis = sbFrame->ScrollBarVisibility(CEikScrollBar::EHorizontal);
        vVis = CEikScrollBarFrame::EOff;
        iVScroll = NULL;
    }

    // Apply new visibility states
    TRAP_IGNORE(sbFrame->SetScrollBarVisibilityL(hVis, vVis));

    // Resize Scrollable, as the client area has changed
    CCoeControl& coeCtrl = CoeControl();
    coeCtrl.SetSize(coeCtrl.Size());

    // Force a redraw here as some Scrollables do not update the screen after
    // a scrollbar as been switched on or off.
    Redraw();
}

// From MSwtScrollable
void ASwtScrollableBase::ComputeTrim(TRect& aRect) const
{
    aRect = BorderOuterRect(SbOuterRect(aRect));
}

TBool ASwtScrollableBase::HasScrollBars() const
{
    TBool hasScrollBars = EFalse;
    CEikScrollBarFrame* sbFrame = SbFrame();
    if (sbFrame)
    {
        if (iHScroll || iVScroll)
        {
            hasScrollBars = ETrue;
        }
    }
    return hasScrollBars;
}

// From ASwtControlBase
TRect ASwtScrollableBase::ClientRect() const
{
    return SbInnerRect(BorderInnerRect());
}

#ifdef RD_SCALABLE_UI_V2
// From MEikScrollBarObserver
void ASwtScrollableBase::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)
{
    if (iVScroll && (aScrollBar == &(iVScroll->EikScrollBar())))
    {
        iVScroll->HandleScrollEventL(aScrollBar, aEventType);
    }
    else if (iHScroll)
    {
        iHScroll->HandleScrollEventL(aScrollBar, aEventType);
    }
}
#else //RD_SCALABLE_UI_V2
void ASwtScrollableBase::HandleScrollEventL(CEikScrollBar*, TEikScrollEvent)
{
}
#endif //RD_SCALABLE_UI_V2