/*
* Copyright (c) 2004 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:  Command absorber to eat all key presses.
*
*/

//INCLUDE FILES
#include <E32std.h>
#include <eikappui.h>
#include <eikenv.h>
#include <eikbtgpc.h>

#include "CCommandAbsorbingControl.h"
#include "CnUiPanics.h"
#include "impscommonuibuilddefinitions.h"


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

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::CCommandFlush()
// -----------------------------------------------------------------------------
//
CCommandAbsorbingControl::CCommandFlush::CCommandFlush()
        : CActive( EPriorityLow )
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::~CCommandFlush()
// -----------------------------------------------------------------------------
//
CCommandAbsorbingControl::CCommandFlush::~CCommandFlush()
    {
    Cancel();
    }

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::Flush()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::CCommandFlush::Flush()
    {
    if ( iWait.IsStarted() )
        {
        //only one flush at time
        return;
        }

    //issue one active scheduler round
    //actually it might be several because this is a low priority one
    //and it lets other higher ones proceed first...
    TRequestStatus *pS = &iStatus;
    User::RequestComplete( pS, KErrNone );
    SetActive();

    //wait with the scheduler loop
    // Code scanner warning "active object called without checking
    // whether it is active or cancelling it first" ignored because
    // CActiveSchedulerWait is not an active object
    iWait.Start(); // CSI: 10 # See above
    }

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::RunL()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::CCommandFlush::RunL()
    {
    Completed();
    }

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::RunError()
// -----------------------------------------------------------------------------
//
TInt CCommandAbsorbingControl::CCommandFlush::RunError( TInt /*aError*/ )
    {
    Completed();
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::DoCancel()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::CCommandFlush::DoCancel()
    {
    Completed();
    }

// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::CCommandFlush::Completed()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::CCommandFlush::Completed()
    {
    //break away from the waiting scheduler loop
    if ( iWait.IsStarted() )
        {
        iWait.AsyncStop();
        }
    }



// ================= MEMBER FUNCTIONS =======================
// Two-phased constructor.
CCommandAbsorbingControl* CCommandAbsorbingControl::NewL()
    {
    CCommandAbsorbingControl* self = new ( ELeave ) CCommandAbsorbingControl();

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }


// Destructor
CCommandAbsorbingControl::~CCommandAbsorbingControl()
    {
    StopAbsorbingIfNeeded();
    }


// C++ default constructor can NOT contain any code, that
// might leave.
//
CCommandAbsorbingControl::CCommandAbsorbingControl()
        : iAbsorbOn( EFalse )
    {
    }


// Symbian OS default constructor can leave.
void CCommandAbsorbingControl::ConstructL()
    {
    //if we don't have application ui,
    //then there is no need to consume commands
    iAppUi = CEikonEnv::Static()->EikAppUi();
    iCba = CEikButtonGroupContainer::Current();
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::AbsorbCommandsLC()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::AbsorbCommandsLC()
    {
    if ( !iAbsorbOn )
        {
        CleanupStack::PushL( TCleanupItem( CCommandAbsorbingControl::ClearCommandAbsorb,
                                           this ) );

        iAbsorbOn = ETrue;
        StartAbsorbingL();
        }

    else
        {
        //already absorbing commands, don't create a new
        //just push NULL object to meet the method semantics
        //this doesn't do actually any harm, just eats one slot from
        //CleanupStack but anyway it is simpler than letting the client
        //manage that it doesn't have anything to pop and destroy...
        CleanupStack::PushL( ( CBase* ) NULL );
        }
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::FlushCommands()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::FlushCommands()
    {
    if ( iAbsorbOn )
        {
        iCommandFlusher.Flush();
        }
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::OfferKeyEventL()
// -----------------------------------------------------------------------------
//
TKeyResponse CCommandAbsorbingControl::OfferKeyEventL( const TKeyEvent& /*aKeyEvent*/,
                                                       TEventCode /*aType*/ )
    {
    return EKeyWasConsumed;
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::StartAbsorbingL()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::StartAbsorbingL()
    {
    if ( iAppUi )
        {
        //add self to eat key events
        iAppUi->AddToStackL( this, ECoeStackPriorityDialog );
        }

    if ( iCba )
        {
        //clear CBA
        MakeCbaVisible( EFalse );
        }
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::StopAbsorbingIfNeeded()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::StopAbsorbingIfNeeded()
    {
    if ( iAbsorbOn )
        {
        if ( iAppUi )
            {
            //remove self
            iAppUi->RemoveFromStack( this );
            }

        if ( iCba )
            {
            //make CBA visible
            MakeCbaVisible( ETrue );
            }

        iAbsorbOn = EFalse;
        }
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::MakeCbaVisible()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::MakeCbaVisible( TBool aVisible ) const
    {
    if ( iCba && iCba->ButtonGroup() )
        {
        TInt leftId( iCba->ButtonGroup()->CommandId( 0 ) );  //position 0 --> left
        TInt rightId( iCba->ButtonGroup()->CommandId( 2 ) ); //position 2 --> right
        TInt mskId = iCba->ButtonGroup()->CommandId( 3 );   // position 3 --> MSK

        iCba->MakeCommandVisible( leftId, aVisible );
        iCba->MakeCommandVisible( rightId, aVisible );
        iCba->MakeCommandVisible( mskId, aVisible );

        iCba->DrawNow();
        }
    }


// -----------------------------------------------------------------------------
// CCommandAbsorbingControl::ClearCommandAbsorb()
// -----------------------------------------------------------------------------
//
void CCommandAbsorbingControl::ClearCommandAbsorb( TAny* aCommandAbsorber )
    {
    __ASSERT_ALWAYS( aCommandAbsorber, CnUiPanic( EIMPSConn_NULLPtr ) );

    CCommandAbsorbingControl* self = static_cast< CCommandAbsorbingControl* >( aCommandAbsorber );
    self->StopAbsorbingIfNeeded();
    }


//  End of File