/*
* Copyright (c) 2006-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:   ?Description
*
*/



#include "uiacceltk/HuiBrushArray.h"
#include "uiacceltk/HuiVisual.h"
#include "uiacceltk/HuiGc.h"
#include "uiacceltk/HuiPanic.h"


EXPORT_C CHuiBrushArray* CHuiBrushArray::NewL()
    {
    CHuiBrushArray* self = NewLC();
    CleanupStack::Pop(self);
    return self;
    }
    
    
EXPORT_C CHuiBrushArray* CHuiBrushArray::NewLC()
    {
    CHuiBrushArray* self = new (ELeave) CHuiBrushArray();
    CleanupStack::PushL(self);
    return self;
    }


CHuiBrushArray::CHuiBrushArray()
    {
    }
    
  
EXPORT_C CHuiBrushArray::~CHuiBrushArray()
    {
    Reset();
    }
  
    
EXPORT_C void CHuiBrushArray::Reset()
    {
    iElements.ResetAndDestroy();
    }


EXPORT_C void CHuiBrushArray::AppendL(CHuiBrush* aBrush, THuiOwnership aOwnership)
    {
    if (!aBrush) // RArrayElement can't handle null ptr correctly in all cases
        {
        User::Leave(KErrArgument);
        }
        
    RArrayElement* element = new (ELeave) RArrayElement();
    CleanupStack::PushL(element);
    User::LeaveIfError(iElements.Append(element));
    CleanupStack::Pop(element);
    
    element->Set(aBrush, aOwnership);
    }


EXPORT_C void CHuiBrushArray::InsertL(TInt aPos, CHuiBrush* aBrush, 
                                      THuiOwnership aOwnership)
    {
    if (!aBrush) // RArrayElement can't handle null ptr correctly in all cases
        {
        User::Leave(KErrArgument);
        }

    RArrayElement* element = new (ELeave) RArrayElement();
    CleanupStack::PushL(element);
    User::LeaveIfError(iElements.Insert(element, aPos));
    CleanupStack::Pop(element);
    
    element->Set(aBrush, aOwnership);
    }


EXPORT_C void CHuiBrushArray::Remove(TInt aPos)
    {
    if ( aPos >= Count() )
        {
        // if does not exist, just return
        return;
        }
    delete iElements[aPos];
    iElements.Remove(aPos);
    }


EXPORT_C TInt CHuiBrushArray::Count() const
    {
    return iElements.Count();
    }
    
    
EXPORT_C CHuiBrush& CHuiBrushArray::operator [] (TInt aPos)
    {
    return iElements[aPos]->Ref();
    }
    
    
EXPORT_C CHuiBrush& CHuiBrushArray::At(TInt aPos)
    {
    return iElements[aPos]->Ref();
    }


EXPORT_C void CHuiBrushArray::Draw(THuiBrushLayer aLayer, CHuiGc& aGc, 
                                   const MHuiBrushGuide& aGuide) const
    {
    TInt layerBrushCount = LayerBrushCount(aLayer);
    TInt depth = 0;

    if(!layerBrushCount)
        {
        // Nothing on this layer.
        return;
        }

    if(aLayer == EHuiBrushLayerBackground)
        {
        depth = -layerBrushCount - 1;
        }
    
    for(TInt i = 0; i < Count(); ++i)
        {
        CHuiBrush& brush = iElements[i]->Ref();
        
        if(brush.Layer() == aLayer)
            {
            // Polygon depth offset to avoid Z-conflicts.
            if(aLayer == EHuiBrushLayerBackground || 
               aLayer == EHuiBrushLayerForeground)
                {
                ++depth;                
                }
            aGc.SetDepthOffset(-depth);
            
            brush.BeginDraw(aGc, aGuide);
            brush.Draw(aGc, aGuide);
            brush.EndDraw(aGc, aGuide);
            }
        }
        
    // Reset depth offset back to zero.
    aGc.SetDepthOffset(0);    
    }


EXPORT_C TInt CHuiBrushArray::LayerBrushCount(THuiBrushLayer aLayer) const
    {
    TInt count = 0;
    
    for(TInt i = 0; i < Count(); ++i)
        {
        if(iElements[i]->Ref().Layer() == aLayer)
            {
            ++count;
            }
        }    
    
    return count;
    }
EXPORT_C TInt CHuiBrushArray::BrushWithTypeCount(TInt aBrushType) const
    {
    TInt count = 0;
    TInt num = Count();
    for(TInt i=0;i<num;i++)
        {
        if (iElements[i]->Ref().Type2()==aBrushType)
            {
            count++;
            }
        }
    return count;
    }
EXPORT_C CHuiBrush *CHuiBrushArray::BrushWithTypeAt(TInt aBrushType, TInt aIndex)
    {
    TInt count = 0;
    TInt num = Count();
    for(TInt i=0;i<num;i++)
        {
        if (iElements[i]->Ref().Type2()==aBrushType)
            {
            if (count == aIndex)
                {
                return &iElements[i]->Ref();
                }
            count++;
            }
        }
    return 0;    
    }
    
    
TBool CHuiBrushArray::Changed() const
    {
    for(TInt i = 0; i < iElements.Count(); ++i)
        {
        if(iElements[i]->Ref().Changed())
            {
            return ETrue;
            }
        }
    return EFalse;
    }
    
    
void CHuiBrushArray::ClearChanged()
    {
    for(TInt i = 0; i < Count(); ++i)
        {
        iElements[i]->Ref().ClearChanged();
        }
    }
    
    
void CHuiBrushArray::ExpandVisualRect(TRect& aRect) const
    {
    TRect original = aRect;
    
    for(TInt i = 0; i < Count(); ++i)
        {
        CHuiBrush& brush = iElements[i]->Ref();

        // If the drawing of the brush is clipped to visual contents,
        // there is no need to expand the rectangle.
        if(!brush.ClipToVisual())
            {
            TRect expanded = original;
            brush.ExpandVisualRect(expanded);
            aRect.BoundingRect(expanded);
            }
        }
    }


void CHuiBrushArray::ActivateBrushGuide(const CHuiVisual* aNewGuide) const
    {
    for(TInt i = 0; i < Count(); ++i)
        {
        CHuiBrush& brush = iElements[i]->Ref();
        brush.ActivateBrushGuide(aNewGuide);
        }        
    }