/*

* Copyright (c) 2002-2005 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:  Implementation of range bar

*

*/

// system includes

//#include <peninputpluginutils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsUtils.h>

#include <AknLayoutDef.h>

#include <AknUtils.h>

#include <barsread.h>

// user includes

#include <peninputrangebar.h>

#include <peninputbutton.h>

#include <peninputmultimodebutton.h>

#include <peninputcommonctrls.hrh>

#include <peninputpluginutils.h>

#include <peninputcommonbutton.h>

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

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

// CAknFepCtrlRangeBar::CAknFepCtrlRangeBar

// C++ constructor

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlRangeBar::CAknFepCtrlRangeBar(CFepUiLayout* aUiLayout, TInt aControlId, 

                                                  TButtonGroupStyle aStyle)

: CControlGroup(aUiLayout, aControlId, EFalse), iFirstTimeConstruct(ETrue)

    {

    iStyle = aStyle;

    //iActionStyle = ERangeBarActionStyleHide;

    iActionStyle = ERangeBarUsingIndicatorStyle;

    }

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

// CAknFepCtrlRangeBar::~CAknFepCtrlRangeBar

// C++ destructor

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlRangeBar::~CAknFepCtrlRangeBar()

    {

    iIndicators.ResetAndDestroy();

    iIndicators.Close();

    iCellRects.Close();

    iCellInnerRects.Close();

    }

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

// CAknFepCtrlRangeBar::NewL

// Two-phased constructor.

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlRangeBar* CAknFepCtrlRangeBar::NewL(CFepUiLayout* aUiLayout, TInt aControlId,

                                                        TButtonGroupStyle aStyle)

    {

    CAknFepCtrlRangeBar* self = new (ELeave) CAknFepCtrlRangeBar (aUiLayout, aControlId, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CAknFepCtrlRangeBar::NewLC

// Two-phased constructor.

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlRangeBar* CAknFepCtrlRangeBar::NewLC(CFepUiLayout* aUiLayout,

                                                         TInt aControlId,

                                                         TButtonGroupStyle aStyle)

    {

    CAknFepCtrlRangeBar* self = new (ELeave) CAknFepCtrlRangeBar (aUiLayout, aControlId, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CAknFepCtrlRangeBar::ConstructL

// Construct the instance

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::ConstructL()

    {

    // Construct the base control first

    CControlGroup::ConstructL();

    }

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

// CAknFepCtrlRangeBar::HandlePointerDownEventL

// Implement the pointer down handler

// (other items were commented in a header).

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

//

CFepUiBaseCtrl* CAknFepCtrlRangeBar::HandlePointerDownEventL(const TPoint& aPoint)

    {

    CFepUiBaseCtrl* ctrl = CControlGroup::HandlePointerDownEventL( aPoint );

    return ctrl;

    }

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

// CAknFepCtrlRangeBar::SizeChanged

// Implement the SizeChanged handler

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::SizeChanged(const TRect aRect)

    {

    SetCellRect(aRect);

    if( iCellChanged )

		{

		SetRect(aRect);

		iActionStyle == ERangeBarUsingIndicatorStyle ? 

        UpdateIndicatorRectForUsingIndicatorStyle(EFalse) :

		UpdateIndicatorRect(EFalse);

		}

    else

		{

		iIsReloadImages = ETrue;

        SetWholeRect();

        //Draw();

        SetIndicatorRect();					

		}

    }

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

// CAknFepCtrlRangeBar::ConstructFromResourceL

// Construct the range bar from the resource

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::ConstructFromResourceL(TResourceReader& aReader)

    {

    //destroy all previous range buttons

    for (TInt ii = 0; ii < iIndicators.Count(); ++ii)

        {

        CAknFepCtrlCommonButton* button = iIndicators[ ii ]->iIndicator;

        if (button)

            {

            RemoveControl(button);

            }

        }

    iIndicators.ResetAndDestroy();

    const TInt countRanges = aReader.ReadInt16();

    if (countRanges <= 0)

        {

        User::Leave(KErrArgument);

        }

    // Create range indicator buttons

    for (TInt ii = 0; ii < countRanges; ++ii)

        {

        AddRangeL(aReader);        

        }

    const TInt defaultRangeIndex = aReader.ReadInt16();

    if (defaultRangeIndex >= 0 && defaultRangeIndex < iIndicators.Count())

        {

        SetRange(iIndicators[defaultRangeIndex]->iInputRange);    

        }

    iFirstTimeConstruct = EFalse;    

    }

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

// CAknFepCtrlRangeBar::SetIndicatorRect()

// Re-calculate the position and layout

// (other items were commented in a header).

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

//

void CAknFepCtrlRangeBar::SetIndicatorRect()

	{

    TRect rect(iIndicatorRect);

    TInt count = iIndicators.Count();

    TInt lastPos = -1;

    for (TInt ii = 0; ii < count; ++ii)

        {  

        if ( ii != 0 && 

		     (iActionStyle != ERangeBarUsingIndicatorStyle || 

             lastPos != iIndicators[ii]->iPosIdx ) )

            {

            if (iStyle == EBtnGroupVertical)

                {

                rect.Move(0, iIndicatorRect.Height());

                }

            else 

                {

                rect.Move(iIndicatorRect.Width(), 0);

                } 

            }

		lastPos = iIndicators[ii]->iPosIdx;

		TRect innerRect;

		AknPenImageUtils::CalculateGraphicRect( rect, innerRect );

        if (iIndicators[ii]->iCtrlType == EButtonTypeMultiMode)

            {

            static_cast<CAknFepCtrlMultiModeButton*>(iIndicators[ii]->iIndicator)->

            			SizeChanged(rect, innerRect, iIsReloadImages);

            }

        else

            {             

            static_cast<CAknFepCtrlCommonButton*>(iIndicators[ii]->iIndicator)->

            			SizeChanged(rect, innerRect, iIsReloadImages);

            }

        }

	}

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

// CAknFepCtrlRangeBar::Draw()

// Re-calculate the position and layout

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::Draw()

    {

	if(!AbleToDraw())

        return;

    CControlGroup::Draw();

    }

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

// CAknFepCtrlRangeBar::RefreshUI

// Refresh the component

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::RefreshUI()

    {

    // this function not called anymore

    SetIndicatorRect();

    // Flush the gc memory to the LCD device

    UpdateArea(iEraseRect, EFalse);               

    }

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

// CAknFepCtrlRangeBar::HandleControlEvent

// responding on button up event

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::HandleControlEvent(TInt aEventType, CFepUiBaseCtrl* aCtrl, 

                                                      const TDesC& /*aEventData*/)

    {

    if (aEventType == EEventButtonUp)

        {

        // get aCtrl's index

        TBool ctrlExist = EFalse;

        TInt ctrlIndex = 0;

        for (TInt ii = 0; ii < iIndicators.Count(); ii++)

            {

            if ((iIndicators[ii]->iIndicator == aCtrl) 

            && (!(iIndicators[ii]->iIndicator->IsDimmed())))

                {

                ctrlExist = ETrue;

                ctrlIndex = ii;

                break;

                }

            }        

        if (!ctrlExist)

            {

            return;

            }

        TBool needSendEvent = EFalse;

        // aCtrl's index is ctrlIndex

        if ( (ActiveControl() != aCtrl) 

            || (iIndicators[ctrlIndex]->iCtrlType == EButtonTypePopupMode) )

            {

            needSendEvent = ETrue;

            }

        else // press active button again

            {

            // only meaningful when it is multimode button

            if (iIndicators[ctrlIndex]->iCtrlType == EButtonTypeMultiMode)

                {

                CAknFepCtrlMultiModeButton* button = static_cast<CAknFepCtrlMultiModeButton*>(iIndicators[ctrlIndex]->iIndicator);

                // change range: user press mixed range multimode button, and range is changed

                if (iIndicators[ctrlIndex]->iRangeType == ERangeTypeMixed)

                    {

                    if ((button->NextMode() != KErrNotFound) && 

                        (button->RangeOfGivenMode(button->CurrentMode()) != 

                         button->RangeOfGivenMode(button->NextMode())))

                        {

                        // change range

                        ReportEventToObserver(iEventIdForRange, 

                                              button->RangeOfGivenMode(button->NextMode()));

                        }

                    else if (button->RangeOfGivenMode(button->CurrentMode()) == 

                             button->RangeOfGivenMode(button->NextMode()))

                        {

                        // mixed range multimode button: change case  

                        ReportEventToObserver(iEventIdForCase, button->NextMode());

                        }

                    }

                else

                    {

                    // single range multimode button: change case

                    ReportEventToObserver(iEventIdForCase, button->NextMode());

                    }

                }

            else

                {

                if ( iIndicators[ctrlIndex]->iInputRange != iInputRange )

                    {

                    needSendEvent = ETrue;

                    }

                }

            }

        if ( needSendEvent )  

            {

            // press another button instead of active button, it will send range event

            if ((iIndicators[ctrlIndex]->iCtrlType == EButtonTypeMultiMode) && 

                (iIndicators[ctrlIndex]->iRangeType == ERangeTypeMixed))

                {

                CAknFepCtrlMultiModeButton* button = 

                                                static_cast<CAknFepCtrlMultiModeButton*>(aCtrl);

                if ((button) && 

                    (button->IsGivenRangeSupported(

                                                button->RangeOfGivenMode(button->CurrentMode()))))

                    {

                    ReportEventToObserver(iEventIdForRange, 

                                          button->RangeOfGivenMode(button->CurrentMode()));

                    }

                }

            else

                {

                // for single range multimode button and normal button

                ReportEventToObserver(iEventIdForRange, iIndicators[ctrlIndex]->iInputRange);

                }                    

            }

        // make sure the normal button press effect for :

        // using indicator style, and EIndicatorActionStyleNormal

        if (iActionStyle == ERangeBarUsingIndicatorStyle && 

            iIndicators[ctrlIndex]->iActionStyle == EIndicatorActionStyleNormal &&

            iIndicators[ctrlIndex]->iIndicator->IsActive())

        	{

        	iIndicators[ctrlIndex]->iIndicator->SetHighlight(EFalse);	

        	}

	    if ( iActionStyle == ERangeBarUsingIndicatorStyle && 

	    	 iIndicators[ctrlIndex]->iActionStyle != EIndicatorActionStyleHighLight )

	    	{

	    	for (TInt ii = 0; ii < iIndicators.Count(); ii++)

		        {

		        if(iIndicators[ ii ]->iActionStyle == EIndicatorActionStyleHighLight

		           && ii != ctrlIndex)

		        	{

		        	iIndicators[ ii ]->iIndicator->SetHighlight( 

		        	  iIndicators[ ii ]->iIndicator->IsActive() );

		        	}

		    	}

	    	}

        }

    }

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

// CAknFepCtrlRangeBar::SetRange

// set current input range

// (other items were commented in a header).

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

//

EXPORT_C TBool CAknFepCtrlRangeBar::SetRange(const TInt aRange)

    {

    // if set range in a mixed range multimode button, 

    // should use detailed range, but not mixed range

    TBool ret = EFalse;

    for (TInt ii = 0; ii < iIndicators.Count(); ii++)

        {

        CAknFepCtrlCommonButton* button = iIndicators[ ii ]->iIndicator;

        if ((button) && (!(button->IsDimmed())))

            {

            if ((iIndicators[ii]->iInputRange == aRange) ||

               ((iIndicators[ii]->iCtrlType == EButtonTypeMultiMode) && 

                (iIndicators[ii]->iRangeType == ERangeTypeMixed) &&             

                (static_cast<CAknFepCtrlMultiModeButton*>(button)->IsGivenRangeSupported(aRange))))

                {

                // 1st condition: normal button or single range multimode button

                // 2nd condition: mixed range multimode button

                if (!(iIndicators[ii]->iInputRange == aRange))

                    {

                    // mixed range multimode button

                    static_cast<CAknFepCtrlMultiModeButton*>(button)->SetRange(aRange);

                    }

                iInputRange = aRange;

                SetActiveCtrl(button);

                ret = ETrue; 

                }

            else

            	{

            	button->SetActive(EFalse);

            	}

            }

        }

    if ( iActionStyle == ERangeBarActionStyleHighLight )

    	{

    	for (TInt ii = 0; ii < iIndicators.Count(); ii++)

	        {

	        iIndicators[ ii ]->iIndicator->SetHighlight( iIndicators[ ii ]->iIndicator->IsActive() );

	    	}

    	}

    else

    	{

    	for (TInt ii = 0; ii < iIndicators.Count(); ii++)

	        {

	        if(iIndicators[ ii ]->iActionStyle == EIndicatorActionStyleHighLight)

	        	{

				iIndicators[ ii ]->iIndicator->SetHighlight( iIndicators[ ii ]->iIndicator->IsActive() );

	        	}

	    	}

    	}

    return ret;    

    }

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

// CAknFepCtrlRangeBar::SetCaseL

// set mode of given range

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::SetCaseL(const TInt aRange, const TInt aModeIndex)

    {

    // aRange is detailed range, it only meaningful for multimodebutton

    for (TInt ii = 0; ii < iIndicators.Count(); ii++)

        {

        CAknFepCtrlMultiModeButton* button = static_cast<CAknFepCtrlMultiModeButton*>

                                             (iIndicators[ii]->iIndicator);            

        if ((iIndicators[ii]->iCtrlType == EButtonTypeMultiMode) && 

            ((iIndicators[ii]->iInputRange == aRange) ||

             ((iIndicators[ii]->iRangeType == ERangeTypeMixed) && 

              (button->IsGivenRangeSupported(aRange)))))

            {            

            if (iIndicators[ii]->iRangeType == ERangeTypeMixed)

                {

                button->SetRange(aRange);

                }

            if (button->IsActive())

                {

                button->SetCurrentModeL(EBtnBmpActive, aModeIndex);

                }

            else

                {

                button->SetCurrentModeL(EBtnBmpNonActive, aModeIndex);

                }

            break;    

            }

        }

    }

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

// CAknFepCtrlRangeBar::SetPermittedRanges

// set permitted ranges

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlRangeBar::SetPermittedRanges(const TInt aPermitted)

    {

    // aPermitted only include detailed range, not mixed    

    for (TInt ii = 0; ii < iIndicators.Count(); ii++)

        {

        TBool needDimButton = EFalse;

        CAknFepCtrlCommonButton* button= iIndicators[ii]->iIndicator;

        if ((iIndicators[ii]->iCtrlType == EButtonTypeMultiMode) && 

            (iIndicators[ii]->iRangeType == ERangeTypeMixed))

            {

            // mixed multi button

            RArray<TInt> rangeList;

            TRAP_IGNORE(static_cast<CAknFepCtrlMultiModeButton*>

                        (button)->GetRangeListL(rangeList));

            needDimButton = ETrue;

            TInt disableIdx = -1;

            for (TInt ii = 0; ii < rangeList.Count(); ii++)

                {

                if (aPermitted & rangeList[ii])

                    {

                    static_cast<CAknFepCtrlMultiModeButton*>(button)->SetPermittedRange(

                                                                   rangeList[ii], ETrue);

                    needDimButton = EFalse;

                    }