/*
* Copyright (c) 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:   Array for brushes
*
*/



#include "alf/alfbrusharray.h"
#include "alf/alfvisual.h"
#include "alf/alfenv.h"
#include "alfclient.h"
#include "alf/alfbrush.h"
#include "alflogger.h"
#include "alf/alfgencomponent.h"
#include "alf/alfconstants.h"

#include <uiacceltk/HuiUtil.h>

/**
 * This watcher is a helper class to detect misusages of the brush arrays.
 *
 * A classic example is that the user creates a brush which is deleted before
 * it is removed from all the arrays where it is added. 
 *
 * This idle-loop is started when the system notices when a brush is deleted which
 * is still in this array. This is only acceptable if the owning visual is deleted
 * in the same scheduler loop. See the CAlfBrushArrayUsageWatcher::RunL
 * for the result if the array is not deleted right away.
 */ 
NONSHARABLE_CLASS(CAlfBrushArrayUsageWatcher) : public CActive
    {
public:
    CAlfBrushArrayUsageWatcher();
    ~CAlfBrushArrayUsageWatcher();
protected:
    void RunL();
    void DoCancel(){};
    };

// Constructor, which initiates the idle-loop
CAlfBrushArrayUsageWatcher::CAlfBrushArrayUsageWatcher() : CActive( EPriorityIdle )
    {
    CActiveScheduler::Add( this );
    
    SetActive();
    iStatus = KRequestPending;
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, KErrNone );
    }

// destructor which cancels the loop    
CAlfBrushArrayUsageWatcher::~CAlfBrushArrayUsageWatcher()
    {
    Cancel();
    }

// RunL is called when the idle-loop is executed.
void CAlfBrushArrayUsageWatcher::RunL()
    {
    // In normal usage, this code snippet should never ne run.
    // This is called, when a user deletes a brush (directly or through a brush array)
    // which is still left in this brush array. 
    
    __ALFLOGSTRING( "CAlfBrushArrayUsageWatcher::RunL Incorrect brush deletion!" )
#ifdef _DEBUG
    USER_INVARIANT();
#endif
    User::Leave( KErrGeneral ); 
    }


// Private data structure.
struct CAlfBrushArray::TPrivateData
    {
    CAlfVisual* iOwner;
    RPointerArray<CAlfBrush> iBrushes;
    RPointerArray<CAlfBrush> iOwnedBrushes;
    CAlfBrushArrayUsageWatcher* iWatcher;
    };
    
// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
CAlfBrushArray::CAlfBrushArray()
    {
    }


// ---------------------------------------------------------------------------
// 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CAlfBrushArray::ConstructL(CAlfVisual& aOwner)
    {
    iData = new (ELeave) TPrivateData;
    
    iData->iOwner = &aOwner;
    iData->iOwnedBrushes.Reset();
    iData->iBrushes.Reset();
    iData->iWatcher = NULL;
    }


// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CAlfBrushArray* CAlfBrushArray::NewL(CAlfVisual& aOwner)
    {
    CAlfBrushArray* self = new( ELeave ) CAlfBrushArray;
    CleanupStack::PushL( self );
    self->ConstructL(aOwner);
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CAlfBrushArray::~CAlfBrushArray()
    {
    if ( iData )
        {
        Reset();
        }
    delete iData;
    iData = NULL;
    }

// ---------------------------------------------------------------------------
// Resets the array.
// ---------------------------------------------------------------------------
//    
EXPORT_C void CAlfBrushArray::Reset()
    {
    for ( TInt i = iData->iBrushes.Count()-1 ; i>= 0; i-- )
        {
        iData->iBrushes[i]->RemoveContainingArray( *this );
        }

    iData->iOwnedBrushes.ResetAndDestroy();
    iData->iBrushes.Reset();
    
    delete iData->iWatcher;
    iData->iWatcher= NULL;
    
    // Update the server side.
    TBuf8<1> dummy;   
    TInt err = iData->iOwner->Comms()->DoSynchronousCmd(EAlfVisualBrushArrayReset, KNullDesC8(), dummy); 

    if ( err )
        {
        __ALFLOGSTRING1( "CAlfBrushArray::Reset panic error %d", err )
        USER_INVARIANT();
        }

    }

// ---------------------------------------------------------------------------
// Add brush onto the array.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfBrushArray::AppendL(CAlfBrush* aBrush, TAlfOwnership aOwnership)
    {
    // Add to iBrushes array.
    TInt err = iData->iBrushes.Append( aBrush );
    if ( err != KErrNone )
        {
        // on failure, log'n'leave
        __ALFLOGSTRING1( "CAlfBrushArray::AppendL leave error %d", err )
        User::Leave( err );
        }
        
    err = aBrush->AppendContainingArray( *this );
    if ( err != KErrNone )
        {
        // on failure remove from iBrushes, log'n'leave
        iData->iBrushes.Remove( iData->iBrushes.Count() - 1 );
        iData->iBrushes.Compress();
        __ALFLOGSTRING1( "CAlfBrushArray::AppendL leave error %d", err )
        User::Leave( err );
        }

    // Update the server side.
    TInt2 int2(aBrush->Identifier(), aOwnership); 
    TPckgC<TInt2> buf(int2);
    TBuf8<1> dum;

    err = iData->iOwner->Comms()->DoSynchronousCmd(EAlfVisualBrushArrayAppend, buf, dum ); 
    if ( err != KErrNone )
        {
        // On error, remove it from the iBrushes and log'n'leave
        RemoveBrush(aBrush, iData->iBrushes.Count() - 1);        
        
        __ALFLOGSTRING1( "CAlfBrushArray::AppendL leave error %d", err )
        User::Leave(err);
        }
    // append ownership only on success (otherwise double deletion takes place on leave)
    if ( aOwnership == EAlfHasOwnership )
        {
        err = iData->iOwnedBrushes.Append( aBrush );
        if ( err != KErrNone )
            {
            // on failure remove brush (inform server as well) and log'n'leave
            Remove( iData->iBrushes.Count() - 1);
            __ALFLOGSTRING1( "CAlfBrushArray::AppendL leave error %d", err )
            User::Leave( err );
            }
        }
    }

// ---------------------------------------------------------------------------
// Insert
// ---------------------------------------------------------------------------
//    
EXPORT_C void CAlfBrushArray::InsertL(TInt aPos, CAlfBrush* aBrush, TAlfOwnership aOwnership)
    {
    // Add to iBrushes array.
    TInt err = iData->iBrushes.Insert( aBrush, aPos );
    if ( err != KErrNone )
        {
        // on failure, log'n'leave
        __ALFLOGSTRING1( "CAlfBrushArray::InsertL leave error %d", err )
        User::Leave( err );
        }
        
    err = aBrush->AppendContainingArray( *this );
    if ( err != KErrNone )
        {
        // on failure remove from iBrushes, log'n'leave
        iData->iBrushes.Remove( aPos );
        iData->iBrushes.Compress();
        __ALFLOGSTRING1( "CAlfBrushArray::InsertL leave error %d", err )
        User::Leave( err );
        }
        
    // Update the server side.
    TInt3 int3(aBrush->Identifier(), aOwnership, aPos); 
    TPckgC<TInt3> buf(int3);
    TBuf8<1> dum;

    err = iData->iOwner->Comms()->DoSynchronousCmd(EAlfVisualBrushArrayInsert, buf, dum ); 
    if ( err != KErrNone )
        {
        // On error, remove it from the iBrushes and log'n'leave 
        RemoveBrush(aBrush, aPos);
        
        __ALFLOGSTRING1( "CAlfBrushArray::InsertL leave error %d", err )
        User::Leave(err);
        }
    
    // append ownership only on success (otherwise double deletion takes place on leave)    
    if ( aOwnership == EAlfHasOwnership )
        {
        err = iData->iOwnedBrushes.Append( aBrush );
        if ( err != KErrNone )
            {
            // on failure remove brush (inform server as well) and log'n'leave
            Remove( aPos );
            __ALFLOGSTRING1( "CAlfBrushArray::InsertL leave error %d", err )
            User::Leave( err );
            }
        }
    }
  
// ---------------------------------------------------------------------------
// Remove
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfBrushArray::Remove(TInt aPos)
    {
    // Update the server side.
    TPckgC<TInt> buf(aPos);
    TBuf8<1> dum;

    TInt err = iData->iOwner->Comms()->DoSynchronousCmd(EAlfVisualBrushArrayRemove, buf, dum ); 
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfBrushArray::Remove panic error %d", err )
        USER_INVARIANT();
        }
    
    RemoveBrush(iData->iBrushes[aPos], aPos);
    }
  
// ---------------------------------------------------------------------------
// Brush count
// ---------------------------------------------------------------------------
//  
EXPORT_C TInt CAlfBrushArray::Count() const
    {
    if ( iData )
        {
        return iData->iBrushes.Count();
        }
    return 0;
    }
  
// ---------------------------------------------------------------------------
// []
// ---------------------------------------------------------------------------
// 
EXPORT_C CAlfBrush& CAlfBrushArray::operator [] (TInt aPos)
    {
    return At(aPos);
    }

// ---------------------------------------------------------------------------
// At
// ---------------------------------------------------------------------------
//
EXPORT_C CAlfBrush& CAlfBrushArray::At(TInt aPos)
    {
    return *iData->iBrushes[aPos];
    }


// ---------------------------------------------------------------------------
// Remove brush and owned brushes if they exist
// ---------------------------------------------------------------------------
//  
void CAlfBrushArray::RemoveBrush(CAlfBrush* aBrush, TInt aPosIndex)
    {
    aBrush->RemoveContainingArray( *this );
            
    const TInt ownedIndex = iData->iOwnedBrushes.Find( aBrush );
    if ( ownedIndex != KErrNotFound )
        {
        iData->iOwnedBrushes.Remove( ownedIndex );
        iData->iOwnedBrushes.Compress();
        delete aBrush;
        }
    
    if ( aPosIndex != KErrNotFound )
        {
        iData->iBrushes.Remove( aPosIndex );
        iData->iBrushes.Compress();
        }
    }

// ---------------------------------------------------------------------------
// Brush is been deleted. Remove it from the array (if exists - might be several times).
// ---------------------------------------------------------------------------
// 
void CAlfBrushArray::HandleBrushDestroyed( CAlfBrush& aBrush )
    {
    for ( TInt index = Count()-1 ; index>=0 ; index-- )
        {
        if ( &At(index) == &aBrush )
            {
            // Update the server side.
            TPckgC<TInt> buf(index);
            TBuf8<1> dum;
            TInt err = iData->iOwner->Comms()->DoSynchronousCmd(EAlfVisualBrushArrayRemove, buf, dum ); 
            if ( err )
                {
                __ALFLOGSTRING1( "CAlfBrushArray::HandleBrushDestroyed panic error %d", err )
                USER_INVARIANT();
                }
            
            // Check the owned brushes - should never found!
            const TInt ownedIndex = iData->iOwnedBrushes.Find( &aBrush );
            __ASSERT_ALWAYS( ownedIndex == KErrNotFound, USER_INVARIANT() );
            
            // Remove from iBrushes array
            iData->iBrushes.Remove( index );
            iData->iBrushes.Compress();
            
            // create watcher
            if ( !iData->iWatcher )
                {
                // do not mind the OOM
                iData->iWatcher = new CAlfBrushArrayUsageWatcher;
                }
            }
        }
    }