/*

* Copyright (c) 2003-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:  The CMIDChoiceGroup listbox model

*

*/

#include "CMIDChoiceGroupModel.h"

#include "CMIDDisplayable.h"

#include <e32def.h>

#include <aknconsts.h>

// using TMifAvkon enumeration

#include <avkon.mbg>

// LAF

// AknLayoutScalable_Avkon::list_single_2graphic_pane_g2_cp4()

#include <aknlayoutscalable_avkon.cdl.h>

#include <j2me/jdebug.h>

// Index where element icons start in the icon array. They're

// preceded by selection state icons (currently 2, selected and nonselected)

const TInt KElementIconStartIndex = 2;

/** This macro is executed each time a trapped call returns an error code different than KErrNone */

#undef  TRAP_INSTRUMENTATION_LEAVE

#define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDChoiceGroupModel.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

// C'tor

CMIDChoiceGroupModel::CMIDChoiceGroupModel(

    MMIDChoiceGroup::TChoiceType aType)

        : CAknFilteredTextListBoxModel(),

        iType(aType),

        iUpdating(EFalse)

{

}

// D'tor

CMIDChoiceGroupModel::~CMIDChoiceGroupModel()

{

    // Delete element array

    if (iElements)

    {

        //all elemnts in iElements array should be destroyed

        //to prevent memory leak

        iElements->ResetAndDestroy();

        delete iElements;

    }

    // Delete icon array, do not delete icons

    if (iIconArray)

    {

        iIconArray->Reset();

        delete iIconArray;

    }

    // Delete icons

    delete iIconSelected;

    delete iIconNotSelected;

    delete iIconDummy;

}

// Two-phase constructor, initialises member arrays and stuff

void CMIDChoiceGroupModel::ConstructL(CEikonEnv* aEikonEnv)

{

    ASSERT(aEikonEnv);

    // Create element array

    iElements = new(ELeave) CArrayPtrFlat<CMIDChoiceGroupElement>(

        KCGElementArrayGranularity);

    // Create icon array

    iIconArray = new(ELeave) CArrayPtrFlat<CGulIcon>(

        KCGElementArrayGranularity);

    ReConstructSelectionIconsL();

    // Create the dummy icon (zero-sized bitmap)

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

    bitmap->Create(TSize(0,0), aEikonEnv->DefaultDisplayMode());

    CleanupStack::PushL(bitmap);

    iIconDummy = CGulIcon::NewL(bitmap);

    CleanupStack::Pop(); // bitmap

}

/** Create selection icons according to type */

void CMIDChoiceGroupModel::ReConstructSelectionIconsL()

{

    TFileName avkonbmpFilename = AknIconUtils::AvkonIconFileName();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    const TAknsItemID& selectedSkinId = (iType == MMIDChoiceGroup::EMultiple) ? KAknsIIDQgnIndiCheckboxOn :

                                        KAknsIIDQgnIndiRadiobuttOn;

    const TAknsItemID& notSelectedSkinId = (iType == MMIDChoiceGroup::EMultiple) ? KAknsIIDQgnIndiCheckboxOff :

                                           KAknsIIDQgnIndiRadiobuttOff;

    TInt selectedIconId = (iType == MMIDChoiceGroup::EMultiple) ? EMbmAvkonQgn_indi_checkbox_on : EMbmAvkonQgn_indi_radiobutt_on;

    TInt selectedMaskId = (iType == MMIDChoiceGroup::EMultiple) ? EMbmAvkonQgn_indi_checkbox_on_mask : EMbmAvkonQgn_indi_radiobutt_on_mask;

    TInt notSelectedIconId = (iType == MMIDChoiceGroup::EMultiple) ? EMbmAvkonQgn_indi_checkbox_off : EMbmAvkonQgn_indi_radiobutt_off;

    TInt notSelectedMaskId = (iType == MMIDChoiceGroup::EMultiple) ? EMbmAvkonQgn_indi_checkbox_off_mask : EMbmAvkonQgn_indi_radiobutt_off_mask;

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    TRect screenRect;

    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, screenRect);

    TAknLayoutRect layoutRect;

    // layout in respect of the whole screen as only the icon size is needed

    layoutRect.LayoutRect(screenRect, AknLayoutScalable_Avkon::list_single_2graphic_pane_g2_cp4().LayoutLine());

    TSize iconSize(layoutRect.Rect().Width(), layoutRect.Rect().Height());

    AknsUtils::CreateColorIconLC(skin, notSelectedSkinId, KAknsIIDQsnIconColors,

                                 EAknsCIQsnIconColorsCG14, bitmap, mask, avkonbmpFilename, notSelectedIconId,

                                 notSelectedMaskId, KRgbBlue, iconSize, EAspectRatioPreservedAndUnusedSpaceRemoved);

    CGulIcon* iconNotSelected = CGulIcon::NewL(bitmap, mask);

    CleanupStack::Pop(2); //bitmap, mask

    delete iIconNotSelected;

    iIconNotSelected = iconNotSelected;

    AknsUtils::CreateColorIconLC(skin, selectedSkinId, KAknsIIDQsnIconColors,

                                 EAknsCIQsnIconColorsCG14, bitmap, mask, avkonbmpFilename, selectedIconId,

                                 selectedMaskId, KRgbBlue, iconSize, EAspectRatioPreservedAndUnusedSpaceRemoved);

    CGulIcon* iconSelected = CGulIcon::NewL(bitmap, mask);

    CleanupStack::Pop(2); //bitmap, mask

    delete iIconSelected;

    iIconSelected = iconSelected;

}

// Base class overrides

// The model contains more than just the strings - need to override

// number of items query

TInt CMIDChoiceGroupModel::NumberOfItems() const

{

    return iElements ? iElements->Count() : 0;

}

// Provides a string with correct indices to images

TPtrC CMIDChoiceGroupModel::ItemText(TInt aItemIndex) const

{

    CMIDChoiceGroupElement* pElement = ElementAt(aItemIndex);

    if (pElement)

    {

        return (pElement->LboxText(aItemIndex + KElementIconStartIndex));

    }

    return TPtrC(KNullDesC);

}

// Base class override

void CMIDChoiceGroupModel::SetItemTextArray(MDesCArray* /*aItemTextArray*/)

{

    // Strings are stored in elements, so this is just to make sure

    // the base class does nothing.

}

// Returns a pointer to the item text array, which is not used,

// because strings are stored inside elements.

MDesCArray* CMIDChoiceGroupModel::ItemTextArray() const

{

    return NULL;

}

// Add an element to the end of the array

void CMIDChoiceGroupModel::AppendElementL(CMIDChoiceGroupElement* aElement)

{

    // Sanity check

    if (!iElements)

    {

        ASSERT(EFalse);

        return;

    }

    // If this is the first added element and choice is single selection

    // type, initially make the first item selected

    if ((iType != MMIDChoiceGroup::EMultiple) && (NumberOfItems() == 0))

    {

        aElement->SetSelected(ETrue);

    }

    iElements->AppendL(aElement);

    // If not in the middle of an update, refresh a bit

    if (!iUpdating)

    {

        // Refresh icon array

        UpdateIconArrayL();

        // Report event

        ReportEventL(MMIDChoiceGroupModelObserver::EElementAdded);

    }

}

// Insert an element at <aIndex>. Space must be reserved.

void CMIDChoiceGroupModel::InsertElementL(

    TInt aIndex,

    CMIDChoiceGroupElement* aElement)

{

    if ((iElements) && (aIndex >= 0) && (aIndex <= NumberOfItems()))

    {

        // If this is the first added element and choice is single selection

        // type, initially make the first inserted item selected

        if ((iType != MMIDChoiceGroup::EMultiple) && (NumberOfItems() == 0))

        {

            aElement->SetSelected(ETrue);

        }

        iElements->InsertL(aIndex, aElement);

        // If not in the middle of an update, refresh a bit

        if (!iUpdating)

        {

            // Refresh icon array

            UpdateIconArrayL();

            // Report element addition

            ReportEventL(MMIDChoiceGroupModelObserver::EElementAdded);

        }

    }

    else

    {

        ASSERT(EFalse);

    }

}

// Delete element at <aIndex>

void CMIDChoiceGroupModel::DeleteElementL(TInt aIndex)

{

    if ((iElements) && (aIndex >= 0) && (aIndex <= NumberOfItems()))

    {

        if (iType != MMIDChoiceGroup::EMultiple && NumberOfItems() > 1)

        {

            CMIDChoiceGroupElement* pElement = ElementAt(aIndex);

            if (pElement)

            {

                if (pElement->IsSelected())

                {

                    if ((aIndex + 1) < NumberOfItems())

                    {

                        CMIDChoiceGroupElement* pNextElement = ElementAt(aIndex+1);

                        pNextElement->SetSelected(ETrue);

                    }

                    else

                    {

                        CMIDChoiceGroupElement* pPrevElement = ElementAt(aIndex-1);

                        pPrevElement->SetSelected(ETrue);

                    }

                }

            }

        }

        // Grab hold of the element for deletion, remove from array

        // and compress the array

        CMIDChoiceGroupElement* ptr = iElements->At(aIndex);

        iElements->Delete(aIndex);

        delete ptr;

        iElements->Compress();

        // If not in the middle of an update, refresh a bit

        if (!iUpdating)

        {

            // Refresh icon array.

            UpdateIconArrayL();

            // Update the looks of the control

            ReportEventL(MMIDChoiceGroupModelObserver::EElementDeleted);

        }

    }

    else

    {

        ASSERT(EFalse);

    }

}

// Delete all elements

void CMIDChoiceGroupModel::DeleteAllL()

{

    if (iElements)

    {

        iElements->ResetAndDestroy();

        // If not updating, refresh now

        if (!iUpdating)

        {

            // Recreate icon array

            UpdateIconArrayL();

            // Report event

            ReportEventL(MMIDChoiceGroupModelObserver::EElementDeleted);

        }

    }

}

// Set properties of element at <aIndex>

void CMIDChoiceGroupModel::SetElementL(

    TInt aIndex,

    const TDesC& aText,

    CFbsBitmap* aBitmap,

    CFbsBitmap* aMask)

{

    CMIDChoiceGroupElement* pElement = ElementAt(aIndex);

    if (pElement)

    {

        // Set new properties

        pElement->SetTextL(aText);

        if (aBitmap)

        {

            pElement->SetIconL(*aBitmap, aMask);

        }

        else

        {

            pElement->SetIcon(NULL, EFalse);

        }

        // Refresh stuff, if not in the middle of an update

        if (!iUpdating)

        {

            // Icon may have changed, recreate array.

            UpdateIconArrayL();

            // Report event

            ReportEventL(MMIDChoiceGroupModelObserver::EElementModified);

        }

    }

}

// Get element at position <aIndex>

CMIDChoiceGroupElement* CMIDChoiceGroupModel::ElementAt(TInt aIndex) const

{

    if ((iElements) && (aIndex >= 0) && (aIndex < NumberOfItems()))

    {

        return iElements->At(aIndex);

    }

    else

    {

        return NULL;

    }

}

// Reserve space for <aCount> elements

void CMIDChoiceGroupModel::SetReserveL(TInt aCount)

{

    if ((iElements) && (aCount >= NumberOfItems()))

    {

        iElements->SetReserveL(aCount);

    }

}

// Retrieves the icon array, recreates if flag is set

CArrayPtr<CGulIcon>* CMIDChoiceGroupModel::IconArray(TBool aReCreate)

{

    if (aReCreate)

    {

        // Recreate, trap & ignore leaves

        TRAP_IGNORE(UpdateIconArrayL());

    }

    return iIconArray;

}

// Set selection state of item at <index>.

// If an item is set selected in an exclusive type choice, also

// deselects other items.

// Deselection of an item in an exlusive choice has no effect.

void CMIDChoiceGroupModel::SelectElementL(TInt aIndex, TBool aSelected)

{

    ASSERT(iElements);

    // Quick sanity check

    if ((aIndex < 0) || (aIndex >= NumberOfItems()))

    {

        return;

    }

    // Exclusive and popup are both single-selection types

    if (iType != MMIDChoiceGroup::EMultiple)

    {

        if (!aSelected)

        {

            // Deselecting in an exclusive - void op

            return;

        }

        // Remove any previous selection

        ClearSelection();

    }

    // Set the selection state of the element

    CMIDChoiceGroupElement* pElement = ElementAt(aIndex);

    if (pElement)

    {

        pElement->SetSelected(aSelected);

    }

    // Report selection

    ReportEventL(MMIDChoiceGroupModelObserver::EElementSelected);

}

// Begin a model update. During an update, the observer will not

// reveive notifications about element actions.

void CMIDChoiceGroupModel::BeginUpdate()

{

    iUpdating = ETrue;

    // Report update start

    TRAP_IGNORE(ReportEventL(MMIDChoiceGroupModelObserver::EUpdateStarted));

}

// End a model update. At the end the icon array will be

// recreated, and the associated control refreshed.

void CMIDChoiceGroupModel::EndUpdate()

{

    iUpdating = EFalse;

    // Create array, refresh control

    // Report update end (observer should redraw)

}

// Returns the index of the selected element in an exclusive

// choice, or -1

TInt CMIDChoiceGroupModel::SelectedElement()

{

    TInt nSelected = -1;

    // Exclusive & Popup are both single-selection

    if (iType != MMIDChoiceGroup::EMultiple)

    {

        // Loop through the elements, look for a selected one

        TInt nCount = NumberOfItems();

        for (TInt i = 0; i < nCount; i++)

        {

            CMIDChoiceGroupElement* pElement = ElementAt(i);

            if (pElement)

            {

                if (pElement->IsSelected())

                {

                    // Found, break out

                    nSelected = i;

                    break;

                }

            }

        }

    }

    return nSelected;

}

// --- private functions ---

// Clears all selections, does not report, as is used when

// subsequently a selection is set (in an exclusive choice)

void CMIDChoiceGroupModel::ClearSelection()

{

    // Loop through the elements and clear element selections

    TInt nCount = NumberOfItems();

    for (TInt i = 0; i < nCount; i++)

    {

        CMIDChoiceGroupElement* pElement = ElementAt(i);

        if (pElement)

        {

            pElement->SetSelected(EFalse);

        }

    }

}

// Reports element actions to observer

void CMIDChoiceGroupModel::ReportEventL(

    MMIDChoiceGroupModelObserver::TChoiceGroupModelEvent aEvent)

{

    if (iObserver)

    {

        iObserver->HandleChoiceGroupModelEventL(this, aEvent);

    }

}

// Create an icon array to be given to the lbox column data.