/*

* Copyright (c) 2002-2007 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:  

*

*/

#include <barsread.h>

#include <coemain.h>

#include <eikbtgpc.h>

#include <eikbtgrp.h>

#include <eikbtgps.h>

#include <eikenv.h>

#include <eikcmobs.h>

#include <eiktbar.h>

#include <eikbtpan.h>

#include <eikpanic.h>

#include "LAFBTGPC.H"

#include <eikbgfty.h>

#include <uikon.hrh>

#include <eikcmbut.h>

#include <aknenv.h>

#include <AknLayout.lag>

#include <AknIconUtils.h>

#include <aknappui.h>

#include <AknUtils.h>

#include <eiklbx.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h> 

#endif

#include <AknTasHook.h>

const TInt KCleanupNoCommand = -1;

const TInt KNoCommand = 0;

const TInt KIsValid = 1;

inline CEikButtonGroupContainer::TCmdPos::TCmdPos()

    : iPos(KCleanupNoCommand), iCmd(KNoCommand)

    {

    }

inline CEikButtonGroupContainer::TCmdPos::TCmdPos(TInt aPos, TInt aCmd)

    : iPos(aPos), iCmd(aCmd)

    {

    }

inline CEikButtonGroupContainer::TCmdObserver::TCmdObserver(TInt aPos, 

    MEikCommandObserver& aObserver)

    : iPos(aPos), iObserver(aObserver)

    {

    }

inline CEikButtonGroupContainer::CCmdObserverArray::CCmdObserverArray()

    : CArrayFixFlat<CEikButtonGroupContainer::TCmdObserver>(1)

    {

    }

TInt CEikButtonGroupContainer::CCmdObserverArray::FindIndex(TInt aPos)

    {

    const TInt count = Count();

    TInt index = KErrNotFound;

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

        {

        if (At(ii).iPos == aPos)

            {

            index = ii;

            break;

            }

        }

    return index;

    }

inline CCoeControl* CEikButtonGroupContainer::ButtonGroupAsControl() const

    {

    CCoeControl* ctrl = iButtonGroup->AsControl();

    // __ASSERT_DEBUG(ctrl...

    return ctrl;

    }

/**

 * Creates a button group container in its own window. Requesting aUse as either EView or 

 * EDialog will create the default button set for the host device; the other options are 

 * included primarily for testing. aOrientation is required only for dialogs on pen based 

 * machines that may layout their buttons either horizontally or vertically. aResourceId 

 * may be NULL if buttons are to be added dynamically.

 */

EXPORT_C CEikButtonGroupContainer* CEikButtonGroupContainer::NewL(

    TUse aUse,

    TOrientation aOrientation,

    MEikCommandObserver* aCommandObserver,

    TInt aResourceId,

    TUint aFlags)

    { // static

    CEikButtonGroupContainer* self = new(ELeave) CEikButtonGroupContainer(aUse);

    CleanupStack::PushL(self);

    self->ConstructL(aOrientation, aCommandObserver, aResourceId, NULL, aFlags);

    CleanupStack::Pop(); // self

    AKNTASHOOK_ADDL( self, "CEikButtonGroupContainer" );

    return self;

    }

/**

 * Creates a button group container in aParent's window. Requesting aUse as either EView or 

 * EDialog will create the default button set for the host device; the other options are 

 * included primarily  for testing. aOrientation is required only for dialogs on pen based 

 * machines that may layout their buttons either horizontally or vertically. aResourceId 

 * may be NULL if buttons are to be added dynamically.

 */

EXPORT_C CEikButtonGroupContainer* CEikButtonGroupContainer::NewL(

    TUse aUse,

    TOrientation aOrientation,

    MEikCommandObserver* aCommandObserver,

    TInt aResourceId,

    const CCoeControl& aParent,

    TUint aFlags)

    { // static

    CEikButtonGroupContainer* self = new(ELeave) CEikButtonGroupContainer(aUse);

    CleanupStack::PushL(self);

    self->SetContainerWindowL(aParent);

    RWindowGroup* targetGroup = NULL;

    if ( aFlags & EIsEmbedded )

        {

        aFlags |= EParentIsControl;

        targetGroup = (RWindowGroup*)&aParent;

        }

    self->ConstructL(aOrientation, aCommandObserver, aResourceId, targetGroup,

            aFlags);

    CleanupStack::Pop(); // self

    AKNTASHOOK_ADDL( self, "CEikButtonGroupContainer" );

    return self;

    }

/**

 * Creates a button group container in aParentWg window group. Requesting aUse as either EView or 

 * EDialog will create the default button set for the host device; the other options are 

 * included primarily  for testing. aOrientation is required only for dialogs on pen based 

 * machines that may layout their buttons either horizontally or vertically. aResourceId 

 * may be NULL if buttons are to be added dynamically.

 */

EXPORT_C CEikButtonGroupContainer* CEikButtonGroupContainer::NewL(

    TUse aUse,

    TOrientation aOrientation,

    MEikCommandObserver* aCommandObserver,

    TInt aResourceId,

    RWindowGroup& aParentWg,

    TUint aFlags)

    { // static

    CEikButtonGroupContainer* self = new(ELeave) CEikButtonGroupContainer(aUse);

    CleanupStack::PushL(self);

    self->ConstructL(aOrientation, aCommandObserver, aResourceId, &aParentWg, aFlags);

    CleanupStack::Pop(); // self

    AKNTASHOOK_ADDL( self, "CEikButtonGroupContainer" );

    return self;

    }

EXPORT_C CEikButtonGroupContainer::~CEikButtonGroupContainer()

    {

    AKNTASHOOK_REMOVE();

    AVKONENV->InformCbaDeletion(this);

    CEikButtonGroupStack::Remove(*this);

    if (iButtonGroup)

        {

        iButtonGroup->Release();

        }

    if (iMSKObserverOwner)

        {

        iMSKObserverOwner->InformMSKButtonGroupDeletion();

        iMSKObserverOwner = NULL;

        }

    delete iCommandsCleanup;

    iCommandsCleanup = NULL;

    delete iObserverArray;

    iValid = KErrNotFound;

    iObserverArray = NULL;

    }

/**

 * Returns a pointer to an app's currently active CEikButtonGroupContainer (if any).

 * Returns NULL if there are no containers active or none suitable for sharing.

 * Ownership of the pointer returned is not transferred.

 */

EXPORT_C CEikButtonGroupContainer* CEikButtonGroupContainer::Current()

    { // static

    return CEikButtonGroupStack::Current();

    }

/**

 * Removes the command identified by aCommandId, in position aPosition in the group, from the

 * command stack. Automatically retrieves the previous command details.

 *

 * Commands are added to the stack by calling AddCommandToStackL. 

 */

EXPORT_C void CEikButtonGroupContainer::RemoveCommandFromStack(TInt aPosition, TInt aCommandId)

    {

    iButtonGroup->RemoveCommandFromStack(aPosition, aCommandId);

    }

EXPORT_C void CEikButtonGroupContainer::SetDefaultCommand(TInt aCommandId)

    {

    iButtonGroup->SetDefaultCommand(aCommandId);

    }

EXPORT_C TSize CEikButtonGroupContainer::CalcMinimumSizeL(TInt aResourceId) const

    {

    return iButtonGroup->CalcMinimumSizeL(aResourceId);

    }

void CEikButtonGroupContainer::CleanupCommandDestroy(TAny* aPtr)

    { // static

    REINTERPRET_CAST(CEikButtonGroupContainer*, aPtr)->DoCleanupCommandPopAndDestroy();

    }

/**

 * Places the command in position aPosition in the group on the cleanup stack. Typically used

 * when a control or view changes the contents of two or more buttons on receipt of focus. 

 * After altering one command with a call to AddCommandToStackL the push is made to

 * guarantee the display will be left in a consistent state if the second (and any subsequent)

 * calls to AddCommandToStackL fail.

 *

 * Only a single command can be pushed for each position.

 */

EXPORT_C void CEikButtonGroupContainer::CleanupCommandPushL(TInt aPosition)

    {

    const TInt count = iCommandsCleanup->Count();

    TBool pushed = EFalse;

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

        {

        TCmdPos& cmdPos = (*iCommandsCleanup)[ii];

        __ASSERT_ALWAYS(cmdPos.iPos != aPosition, Panic(EEikPanicButtonGroupDuplicateCleanupPos));  

        if (cmdPos.iPos == KCleanupNoCommand)

            {

            cmdPos.iPos = aPosition;

            cmdPos.iCmd = iButtonGroup->CommandId(aPosition);

            pushed = ETrue;

            break;

            }

        }

    __ASSERT_ALWAYS(pushed, Panic(EEikPanicButtonGroupCleanupCorrupt));

    CleanupStack::PushL(TCleanupItem(CleanupCommandDestroy, this));

    }

/**

 * Removes a command (or aCount commands) altered by calling AddCommandToStackL from the cleanup

 * stack without changing its state.

 */

EXPORT_C void CEikButtonGroupContainer::CleanupCommandPop(TInt aCount)

    {

    while (aCount--)

        {

        DoCleanupCommandPop();

        CleanupStack::Pop();

        }

    }

CEikButtonGroupContainer::TCmdPos CEikButtonGroupContainer::DoCleanupCommandPop()

    {

    const TInt count = iCommandsCleanup->Count();

    TInt index = -1;

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

        {

        if ((*iCommandsCleanup)[ii].iPos == KCleanupNoCommand)

            {

            index = ii - 1;

            __ASSERT_DEBUG(index != -1, Panic(EEikPanicButtonGroupCleanupCorrupt));

            break;

            }

        }

    if (index == -1)

        { // all cleanup slots are filled

        index = count-1;

        }

    TCmdPos cmdPos = (*iCommandsCleanup)[index];

    iCommandsCleanup->At(index) = TCmdPos();

    return cmdPos;

    }

void CEikButtonGroupContainer::DoCleanupCommandPopAndDestroy()

    {

    TCmdPos cmdPos = DoCleanupCommandPop();

    RemoveCommandFromStack(cmdPos.iPos, cmdPos.iCmd);

    }

/**

 * Returns the maximum number of commands a particular device supports.

 */

EXPORT_C TInt CEikButtonGroupContainer::MaxCommands() const

    {

    return 4; // !!! need to get this from LAF

    }

/**

 * Returns the number of buttons currently present.

 */

EXPORT_C TInt CEikButtonGroupContainer::ButtonCount() const

    {

    return iButtonGroup->ButtonCount();

    }

EXPORT_C void CEikButtonGroupContainer::DimCommand(TInt aCommandId, TBool aDimmed)

    {

    iButtonGroup->DimCommand(aCommandId, aDimmed);

    }

EXPORT_C TBool CEikButtonGroupContainer::IsCommandDimmed(TInt aCommandId) const

    {

    return iButtonGroup->IsCommandDimmed(aCommandId);

    }

EXPORT_C void CEikButtonGroupContainer::MakeCommandVisible(TInt aCommandId, TBool aVisible)

    {

    iButtonGroup->MakeCommandVisible(aCommandId, aVisible);

    }

EXPORT_C TBool CEikButtonGroupContainer::IsCommandVisible(TInt aCommandId) const

    {

    return iButtonGroup->IsCommandVisible(aCommandId);

    }

EXPORT_C void CEikButtonGroupContainer::AnimateCommand(TInt aCommandId)

    {

    iButtonGroup->AnimateCommand(aCommandId);

    }

EXPORT_C void CEikButtonGroupContainer::DimCommandByPosition(TCommandPosition aPosition, 

    TBool aDimmed)

    {

    iButtonGroup->DimCommandByPosition((TInt)aPosition, aDimmed);

    }

EXPORT_C TBool CEikButtonGroupContainer::IsCommandDimmedByPosition(TCommandPosition aPosition) const

    {

    return iButtonGroup->IsCommandDimmedByPosition((TInt)aPosition);

    }

EXPORT_C void CEikButtonGroupContainer::MakeCommandVisibleByPosition(TCommandPosition aPosition, 

    TBool aVisible)

    {

    iButtonGroup->MakeCommandVisibleByPosition((TInt)aPosition, aVisible);

    }

EXPORT_C TBool CEikButtonGroupContainer::IsCommandVisibleByPosition(

    TCommandPosition aPosition) const

    {

    return iButtonGroup->IsCommandVisibleByPosition((TInt)aPosition);

    }

EXPORT_C void CEikButtonGroupContainer::AnimateCommandByPosition(TCommandPosition aPosition)

    {

    iButtonGroup->AnimateCommandByPosition((TInt)aPosition);

    }

EXPORT_C TSize CEikButtonGroupContainer::MinimumSize()

    {

    TSize size = ButtonGroupAsControl()->MinimumSize();

    // add borders size from LAF

    return size;

    }

CEikButtonGroupContainer::CEikButtonGroupContainer(TUse aUse)

    : iUse(aUse)

    {

    SetComponentsToInheritVisibility();

    }

void CEikButtonGroupContainer::ConstructL(

    TOrientation aOrientation,

    MEikCommandObserver* aCommandObserver,

    TInt aResourceId,

    RWindowGroup* aParentWg,

    TUint aFlags)

    {

    iValid = KIsValid;

    iCommandObserver = aCommandObserver;

    const TInt numCmds = MaxCommands();

    iCommandsCleanup = new(ELeave) CArrayFixFlat<TCmdPos>(numCmds);

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

        {

        iCommandsCleanup->AppendL(TCmdPos());

        }

    TInt buttonType = LafButtonGroupContainer::ButtonType(iUse);

    TBool addToButtonGroupStack = EFalse;

    EikButtonGroupFactory::TCreationData creationData(

        iUse,

        this,

        aResourceId,

        aParentWg,

        aFlags,

        aOrientation);

    iButtonGroup = (MEikButtonGroup*)EikButtonGroupFactory::CreateButtonGroupByTypeL(

        buttonType,

        creationData,

        addToButtonGroupStack);

    __ASSERT_ALWAYS(iButtonGroup, Panic(EEikPanicButtonGroupNotFoundInFactory));

    if(addToButtonGroupStack)

        {

        CEikButtonGroupStack::AddL(*this);

        }

    SetContainerWindowL(*(iButtonGroup->AsControl()));

    SetParent( NULL );

    // __ASSERT_DEBUG(iButtonGroup==NULL...

    if (!(aFlags&EDelayActivation))

        {

        ActivateL();

        }

    }

/**

 * Sets the text, bitmaps and command ids specified at aResourceId into the buttons.

 *

 * @since ER5U 

 */

EXPORT_C void CEikButtonGroupContainer::SetCommandSetL(TInt aResourceId)

    {

    iButtonGroup->SetCommandSetL(aResourceId);

    }

/**

 * As with SetCommandL but allows the previous command to be retrieved at 

 * any time by calling RemoveCommand.  Panics if aPosition is out of range.

 *

 * @since ER5U 

 */

EXPORT_C void CEikButtonGroupContainer::AddCommandSetToStackL(TInt aResourceId)

    {

    iButtonGroup->AddCommandSetToStackL(aResourceId);

    }

EXPORT_C void CEikButtonGroupContainer::DoSetCommandL(

    TInt aPosition,

    TInt aCommandId,

    const TDesC* aText,

    const CFbsBitmap* aBitmap,

    const CFbsBitmap* aMask,

    TCommandOp aOp)

    {

    TPtrC text;

    if (aText)

        {

        text.Set(*aText);

        }

    else

        {

        text.Set(KNullDesC);

        }

    switch (aOp)

        {

        case ESet:

            iButtonGroup->SetCommandL(aPosition, aCommandId, &text, aBitmap, aMask);

            break;

        case EAdd:

            iButtonGroup->AddCommandL(aPosition, aCommandId, &text, aBitmap, aMask);

            break;

        case EPush:

            // slightly wasteful - could check whether extra slot is required first        

            iCommandsCleanup->AppendL(TCmdPos()); 

            iButtonGroup->AddCommandToStackL(aPosition, aCommandId, &text, aBitmap, aMask);

            break;

        }

    }

EXPORT_C void CEikButtonGroupContainer::DoSetCommandL(

    TInt aPosition,

    TInt aCommandId,

    const TDesC* aText,

    const TDesC& aFile,

    TInt aBitmapId,

    TInt aMaskId,

    TCommandOp aOp)

    {

    CFbsBitmap* bitmap = AknIconUtils::CreateIconL(aFile, aBitmapId);

    CleanupStack::PushL(bitmap);

    CFbsBitmap* mask = AknIconUtils::CreateIconL(aFile, aMaskId);

    CleanupStack::PushL(mask);

    DoSetCommandL(aPosition, aCommandId, aText, bitmap, mask, aOp);

    }

EXPORT_C void CEikButtonGroupContainer::DoSetCommandL(

    TInt aCommandId,

    const TDesC* aText,

    const CFbsBitmap* aBitmap,

    const CFbsBitmap* aMask,

    TCommandOp aOp)

    {

    const TInt pos = PositionById(aCommandId);

    if (pos == KErrNotFound)

        {

        User::LeaveIfError(KErrNotFound);

        }

    DoSetCommandL(pos, aCommandId, aText, aBitmap, aMask, aOp);

    }

EXPORT_C void CEikButtonGroupContainer::DoSetCommandL(

    TInt aCommandId,

    const TDesC* aText,

    const TDesC& aFile,

    TInt aBitmapId,

    TInt aMaskId,

    TCommandOp aOp)

    {

    const TInt pos = PositionById(aCommandId);

    if (pos == KErrNotFound)

        {

        User::LeaveIfError(KErrNotFound);

        }