/*

* Copyright (c) 1997-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include <eikscrlb.h>

#include <eikpanic.h>

#include <eikcoctlpanic.h>

#include <eikenv.h>

#include <AknLayout.lag>

#include <eikcba.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <aknappui.h>

#include <AknsUtils.h>

#include <AknLayout2ScalableDef.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknInfoPopupNoteController.h>

#include <aknpointereventmodifier.h>

#include <AknTasHook.h>

#include <touchfeedback.h>

#include "AknDoubleSpanScrollIndicator.h"

#include "eikscrlb.h"

#include "EIKSBEXT.H"

const TInt KScrollBarWidth=9;

// const TInt KScrollButtonHeight=10;

// const TInt KArrowHeadScrollBarLength=20;

// Constants for double span scrollbar

const TInt KAknDoubleSpanScrollBarWidth = 6;

const TInt KDoubleSpanMaxModelValue     = 0x1FFF7FFF;

const TInt KDoubleSpanMinModelValue     = -0x1FFF7FFF;

const TInt16 KDoubleSpanMaxScaleValue   = 0x3FFF;

const TInt16 KDoubleSpanMinScaleValue   = 1;

const TInt KDoubleSpanMaxRawValue       = 0x8000;

// Mask values for double span scrollbar

const TUint KDoubleSpanModelMaskBitsHigh       = 0xFFFF0000;

const TUint KDoubleSpanModelMaskBitsLow        = 0x0000FFFF;

const TUint KDoubleSpanModelMaskBitsScale      = 0x3FFF0000;

const TUint KDoubleSpanModelMaskBitsType       = 0x3FFFFFFF;

const TUint16 KDoubleSpanModelMaskBitsScale16 = 0x3FFF;

const TInt KScrollRepeatTimeout = 250000; // 0.25 seconds

const TInt KScrollDragTimeout =    66000; // 0.66 seconds means 16 fps

EXPORT_C TBool TEikScrollBarModel::operator==(const TEikScrollBarModel aModel) const

    {

    return ((iScrollSpan==aModel.iScrollSpan)&(iThumbSpan==aModel.iThumbSpan)&(iThumbPosition==aModel.iThumbPosition));

    }

EXPORT_C TEikScrollBarModel::TEikScrollBarModel(TInt aScrollSpan,TInt aThumbSpan,TInt aThumbPosition)

    : iScrollSpan(aScrollSpan),

    iThumbSpan(aThumbSpan),

    iThumbPosition(aThumbPosition)

    {}

EXPORT_C TBool TEikScrollBarModel::ScrollBarUseful() const

    {

    return iThumbSpan<iScrollSpan;

    }

EXPORT_C TInt TEikScrollBarModel::MaxThumbPos() const

    {

    return iScrollSpan-iThumbSpan;

    }

EXPORT_C void TEikScrollBarModel::CheckBounds()

// Ensure the thumbposition remains within it's valid range

    {

    iThumbPosition=Max(0,Min(iThumbPosition,iScrollSpan-1));

    }

TEikScrollBarModel::TEikScrollBarModelType TEikScrollBarModel::ScrollBarModelType() const

    {

    TUint type = (~KDoubleSpanModelMaskBitsType) & iScrollSpan;

    if (type == EAknDoubleSpanScrollBarModel)

        {

        return EAknDoubleSpanScrollBarModel;

        }

    else

        {

        return EEikScrollBarModel;

        }

    }

//

// CEikScrollBar class

//

EXPORT_C CEikScrollBar::~CEikScrollBar()

// Destructor

    {

    AKNTASHOOK_REMOVE();

    DisconnectExternalFrames();

    delete(iButtons.iIncreaseNudge);

    delete(iButtons.iDecreaseNudge);

    delete iExtension;

    }

EXPORT_C CEikScrollBar::CEikScrollBar()

// Default constructor

    {

    SetNonFocusing();

    SetComponentsToInheritVisibility();

    AKNTASHOOK_ADD( this, "CEikScrollBar" );

    }

EXPORT_C void CEikScrollBar::ConstructL(MEikScrollBarObserver* aScrollBarObserver,const CCoeControl* aParent,

                                        TOrientation aOrientation,TInt /*aLength*/,TInt /*aScrollBarFlags*/)

// Second-phase construction

    {

    // If extension has not been created by deriving class, create default extension.

    if (!iExtension)

        {

        iExtension = new(ELeave) CEikScrollBarExtension(this);

        }

    if(AknLayoutUtils::PenEnabled())

        {

        CEikScrollBarExtension* extension = static_cast<CEikScrollBarExtension*> (iExtension);

        extension->SetScrollBarObserver(aScrollBarObserver);

        }

    CreateWindowL(aParent);

    if(aParent)

        SetObserver(aParent->Observer());

    else

        SetObserver(NULL);

    iOrientation=aOrientation;

    // Fix scrollbar frame's position to middle of cba

    CreateRequiredComponentsL();

    Window().SetPointerGrab(ETrue);

    EnableDragEvents();

    MakeVisible(EFalse);

    ActivateL();

    }

EXPORT_C TInt CEikScrollBar::CountComponentControls() const

    {

    TInt controlCount = 0;

    if(iButtons.iIncreaseNudge)

        {

        controlCount++;

        }

    if(iButtons.iDecreaseNudge)

        {

        controlCount++;

        }

    return controlCount;

    }

EXPORT_C CCoeControl* CEikScrollBar::ComponentControl(TInt aIndex) const

    {

    if (aIndex==0)

        return iButtons.iIncreaseNudge;

    else

        return iButtons.iDecreaseNudge;

    }

EXPORT_C void CEikScrollBar::SetLengthL(TInt /*aLength*/)

// Change the scrollbar's length.  Will redraw

    {

    }

EXPORT_C void CEikScrollBar::SetModelL(const TEikScrollBarModel* aModel)

    {

    SetModel(aModel);

    }

EXPORT_C void CEikScrollBar::SetModel(const TEikScrollBarModel* aModel)

// Change the scrollbar model

    {

    if (*aModel==iModel)

        return;

    DoSetModel(aModel);

    }

EXPORT_C void CEikScrollBar::SetLengthAndModelL(TInt /*aLength*/,const TEikScrollBarModel* aModel)

// Change the length and model at once to avoid a double update of the scrollbar

    {

    SetModel(aModel);

    }

EXPORT_C void CEikScrollBar::SetModelThumbPosition(TInt /*aThumbPos*/)

    {

    }

EXPORT_C void CEikScrollBar::SetFocusPosToThumbPos(TInt /*aFocusPosition*/)

    {

    }

EXPORT_C TInt CEikScrollBar::ThumbPosition() const

// Retrun the model's thumb position (eg in response to a scroll event)

    {

    if (iExtension)

        {

        return iExtension->ThumbPosition();

        }

    else

        {

        return 0;

        }

    }

EXPORT_C TInt CEikScrollBar::ScrollBarBreadth() const

// returns the height of a horizontal scrollbar or width of a vertical scrollbar

    {

    if (iExtension)

        {

        return iExtension->ScrollBarBreadth();

        }

    else

        {

        return 0;

        }

    }

EXPORT_C TInt CEikScrollBar::MinVisibleLength(const TInt /*aScrollBarFlags*/)

// STATIC - Calculates the minimum length in which scrollbar will remain "visible" (not necessarily with all it's components though)

    {

    return 0;

    }

EXPORT_C void CEikScrollBar::SetDecreaseButtonsDimmed(TBool /*aDimmed*/)

// Dim out the decrease buttons

    {

    }

EXPORT_C void CEikScrollBar::SetIncreaseButtonsDimmed(TBool /*aDimmed*/)

// Dim out the increase buttons

    {

    }

EXPORT_C void CEikScrollBar::SetAllButtonsDimmed(TBool /*aDimmed*/)

// Dim out all buttons

    {

    }

void CEikScrollBar::CreateRequiredComponentsL()

// Allocates and constructs all the required components of the scrollbar

    {

    if (iExtension)

        {

        iExtension->CreateRequiredComponentsL();

        }

    }

EXPORT_C void CEikScrollBar::CreateButtonL(CAknScrollButton*& /*aButton*/,CAknScrollButton::TType /*aType*/)

// Create the appropriate button

    {

    }

void CEikScrollBar::DestroyButton(CAknScrollButton*& aButton)

// destroy a button

    {

    delete aButton;

    aButton=NULL;

    }

EXPORT_C void CEikScrollBar::SetButtonPositionL(CAknScrollButton* /*aButton*/)

// Calculates and sets a buttons position,making necessary adjustments for densely packed buttons

    {

    }

void CEikScrollBar::DoSetModel(const TEikScrollBarModel* aModel)

// Just change the internal model checking it's valid

    {

    if (iExtension)

        {

        iExtension->DoSetModel(aModel);

        }

    }

void CEikScrollBar::SizeChanged()

    {

    // Update position of components

    if (iButtons.iIncreaseNudge)

        {

        TRAP_IGNORE(SetButtonPositionL(iButtons.iIncreaseNudge));

        }

    if (iButtons.iDecreaseNudge)

        {

        TRAP_IGNORE(SetButtonPositionL(iButtons.iDecreaseNudge));

        }

    }

EXPORT_C TInt CEikScrollBar::DefaultScrollBarBreadth()

    {

    return KScrollBarWidth;

    }

EXPORT_C void CEikScrollBar::HandleControlEventL(CCoeControl* /*aControl*/, TCoeEvent /*aEventType*/)

    {

    }

EXPORT_C void CEikScrollBar::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

    CEikBorderedControl::HandlePointerEventL(aPointerEvent);

    }

EXPORT_C void CEikScrollBar::SetExtensionAreaType(TScrollBarExtensionAreaType aType)

    {

    if(ScrollBarType() == CEikScrollBar::EDoubleSpan)

        {

        CAknDoubleSpanScrollBarExtension* extension = static_cast<CAknDoubleSpanScrollBarExtension*> (iExtension);

        extension->iExtensionType = aType;

        }

    }

EXPORT_C void* CEikScrollBar::ExtensionInterface( TUid /*aInterface*/ )

    {

    return NULL;

    }

EXPORT_C void CEikScrollBar::Reserved_2()

    {

    }

EXPORT_C void CEikScrollBar::MakeVisible(TBool aVisible)

    {

    if (COMPARE_BOOLS(aVisible, IsVisible()))

        return;

    TAknWindowLineLayout lay(AKN_LAYOUT_WINDOW_Control_pane_elements_Line_1);

    TAknLayoutRect lr;

    lr.LayoutRect( Rect(), lay );

    TRect r( lr.Rect() );

    SetExtent( r.iTl, TSize( aVisible ? r.Width() : 0, 2 * r.Height() ) );

    // Arrow head scroll bar will not be displayed

    if ( iExtension->ScrollBarType() == CEikScrollBar::EArrowHead )

        {

        CCoeControl::MakeVisible( EFalse );

        }

    else

        {

        CCoeControl::MakeVisible( aVisible );

        }

    if (Cba())

        {

        Cba()->UpdateCbaLabels( aVisible );

        }

    }

EXPORT_C void CEikScrollBar::SetContainingCba(CEikCba* aCba)

    {

    // This is technically a compatability break, because it means that SetContainingCba

    // must only be called after ConstructL(). Fortunately, the only place where this API

    // should ever be called is already correct.

    __ASSERT_ALWAYS(iExtension, Panic(EEikPanicScrollBarExtensionNotCreated));

    iExtension->SetContainingCba(aCba);

    }

CEikCba* CEikScrollBar::Cba() const

    {

    if (iExtension)

        return iExtension->Cba();

    else

        return NULL;

    }

void CEikScrollBar::AddExternalFrameL(CEikScrollBarFrame* aFrame)

    {

    __ASSERT_ALWAYS(iExtension, Panic(EEikPanicScrollBarExtensionNotCreated));

    iExtension->AddExternalFrameL(aFrame);

    }

void CEikScrollBar::RemoveExternalFrame(CEikScrollBarFrame* aFrame)

    {

    __ASSERT_ALWAYS(iExtension, Panic(EEikPanicScrollBarExtensionNotCreated));

    iExtension->RemoveExternalFrame(aFrame);

    }

void CEikScrollBar::DisconnectExternalFrames()

    {

    if (iExtension)

        {

        iExtension->DisconnectExternalFrames();

        }

    }

CEikScrollBar::TScrollBarType CEikScrollBar::ScrollBarType()

    {

    if (iExtension)

        {

        return static_cast<CEikScrollBar::TScrollBarType> (iExtension->ScrollBarType());

        }

    return CEikScrollBar::TScrollBarType(ENormalScrollBar);

     }

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

// CEikScrollBar::SetScrollBarObserver

//

// Sets scroll bar observer. This enables changing of the observer also after the

// scroll bar has been constructed.

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

//

void CEikScrollBar::SetScrollBarObserver(MEikScrollBarObserver* aScrollBarObserver)

    {

    if( !AknLayoutUtils::PenEnabled() )

        {

        return;

        }

    if(ScrollBarType() == CEikScrollBar::EDoubleSpan)

        {

        CAknDoubleSpanScrollBarExtension* extension = static_cast<CAknDoubleSpanScrollBarExtension*> (iExtension);

        extension->SetScrollBarObserver(aScrollBarObserver);

        }

    else

        {

        CEikScrollBarExtension* extension = static_cast<CEikScrollBarExtension*> (iExtension);

        extension->SetScrollBarObserver(aScrollBarObserver);

        }

    }

//

// class CEikScrollBarExtension

//

CEikScrollBarExtension::CEikScrollBarExtension(CEikScrollBar* aParent)

: iExternalFrames(1)

    {

    iParent=aParent;

    }

CEikScrollBarExtension::~CEikScrollBarExtension()

    {

    }

void CEikScrollBarExtension::SetLengthL(TInt /*aLength*/)

    {

    }

void CEikScrollBarExtension::SetModelL(const TEikScrollBarModel* /*aModel*/)

    {

    }

void CEikScrollBarExtension::SetModel(const TEikScrollBarModel* /*aModel*/)

    {

    }

void CEikScrollBarExtension::SetLengthAndModelL(TInt /*aLength*/,const TEikScrollBarModel* /*aModel*/)

    {

    }

void CEikScrollBarExtension::SetModelThumbPosition(TInt /*aThumbPos*/)

    {

    }

void CEikScrollBarExtension::SetFocusPosToThumbPos(TInt /*aFocusPosition*/)

    {

    }

TInt CEikScrollBarExtension::ThumbPosition() const

    {

    return(iParent->iModel.iThumbPosition);

    }

TInt CEikScrollBarExtension::ScrollBarBreadth() const

    {

    if (iParent->iOrientation==CEikScrollBar::EHorizontal)

        return iParent->iSize.iHeight;

    return iParent->iSize.iWidth;

    }

void CEikScrollBarExtension::SetDecreaseButtonsDimmed(TBool /*aDimmed*/)

    {

    }

void CEikScrollBarExtension::SetIncreaseButtonsDimmed(TBool /*aDimmed*/)

    {

    }

void CEikScrollBarExtension::SetAllButtonsDimmed(TBool /*aDimmed*/)

    {

    }

void CEikScrollBarExtension::SetContainingCba(CEikCba* aCba)

    {

    iCba = aCba;

    }

TInt CEikScrollBarExtension::ScrollBarType()

    {

    return CEikScrollBar::EArrowHead;

    }

void CEikScrollBarExtension::DoSetModel(const TEikScrollBarModel* aModel)

    {

    iParent->iModel=(*aModel);

    iParent->iModel.CheckBounds();

    TInt focusPosition=iParent->iModel.iThumbPosition;

    if ((focusPosition!=-1) && iParent && iParent->iButtons.iIncreaseNudge && iParent->iButtons.iDecreaseNudge)

        {

        iParent->iButtons.iIncreaseNudge->SetPosition(focusPosition, iParent->iModel.iScrollSpan);

        iParent->iButtons.iDecreaseNudge->SetPosition(focusPosition, iParent->iModel.iScrollSpan);

        }

    }