/*
* Copyright (c) 2003 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:   CScreensaverIndicatorArray implementation.
*
*/



#include <barsread.h>
#include <screensaver.rsg>
#include <AknUtils.h>

#include "screensaverindicatorarray.h"
#include "screensaverindicatornumberandicon.h"
#include "screensaverindicatortext.h"
#include "screensaverindicatoricon.h"
#include "screensaverutility.h"

const TInt KInvertedColors = 1;


// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::NewL
// -----------------------------------------------------------------------------
//
CScreensaverIndicatorArray* CScreensaverIndicatorArray::NewL( TBool aColorInversionUsed )
    {
    CScreensaverIndicatorArray* array = new(ELeave) CScreensaverIndicatorArray();
    CleanupStack::PushL(array);
    array->ConstructL( aColorInversionUsed );
    CleanupStack::Pop(); // array

    return array;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::~CScreensaverIndicatorArray
// -----------------------------------------------------------------------------
//
CScreensaverIndicatorArray::~CScreensaverIndicatorArray()
    {
    if (iIndicators)
        {
        iIndicators->ResetAndDestroy();
        }
    delete iIndicators;
    delete iDependencyRecord;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::NewIndicatorLC
// -----------------------------------------------------------------------------
//
CScreensaverIndicator *CScreensaverIndicatorArray::NewIndicatorLC(
        TScreensaverIndicatorType aId)
    {
    CScreensaverIndicator *result= NULL;

    switch (aId)
        {
        case ESsIconIndicator:
            result = new( ELeave ) CScreensaverIndicatorIcon();
            break;
        case ESsTextIndicator:
            result = new( ELeave ) CScreensaverIndicatorText();
            break;
        case ESsNumberAndIconIndicator:
            result = new( ELeave ) CScreensaverIndicatorNumberAndIcon();
            break;
        default:
            User::Leave(KErrCorrupt);
        }

    CleanupStack::PushL( result );
    result->SetType(aId);

    return result;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::ConstructL
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::ConstructL( TBool aColorInversionUsed )
    {
    if (aColorInversionUsed == KInvertedColors)
        {
        iBgColor = TRgb(KRgbBlack).Value();
        iTextColor = TRgb(KRgbWhite).Value();
        }
    else //aColorInversionUsed == KNormalColors
        {
        iBgColor = TRgb(KRgbWhite).Value();
        iTextColor = TRgb(KRgbBlack).Value();
        }
    
    ConstructFromResourceL();

    }


// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::ConstructFromResourceL
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::ConstructFromResourceL()
    {
    ConstructParamFromResourceL();

    ConstructIndArrayL();
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::ConstructParamFromResourceL
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::ConstructParamFromResourceL()
    {
    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC( reader, R_SCREENSAVER_PARAMETERS );
    iMargin = reader.ReadInt16();
    iGap = reader.ReadInt16();
    iTopMargin = reader.ReadInt16();
    iTextLevel = reader.ReadInt16();
    iHeight = reader.ReadInt16();
    CleanupStack::PopAndDestroy(); // reader
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::ConstructIndArrayL
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::ConstructIndArrayL()
    {
    if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
        {//use the new layout
        ConstructIndicatorsL( R_SCREENSAVER_INDICATOR_ARRAY_NEW_LAYOUT );
        }
    else
        {//use the old layout
        ConstructIndicatorsL( R_SCREENSAVER_INDICATOR_ARRAY );
        }
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::ConstructIndicatorsL
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::ConstructIndicatorsL( TInt aResourceId )
    {
    TResourceReader reader;

    CEikonEnv::Static()->CreateResourceReaderLC(
        reader, aResourceId);
    
    iCount = reader.ReadInt16();

    iIndicators = new( ELeave ) CArrayPtrFlat<CScreensaverIndicator>( iCount );
    iDependencyRecord = new( ELeave ) CArrayFixFlat<TBool>( iCount );

    CScreensaverIndicator *nInd;
    TInt32 type;
    for (TInt i = 0; i < iCount; i++)
        {
        iDependencyRecord->AppendL( ETrue );
        type = reader.ReadInt32();
        nInd = NewIndicatorLC( ( TScreensaverIndicatorType ) type );
        nInd->ConstructL( reader, iBgColor, iTextColor );
        iIndicators->InsertL( 0, nInd );
        CleanupStack::Pop(); // nInd
        }

    CleanupStack::PopAndDestroy(); // reader
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::Dependency
// -----------------------------------------------------------------------------
//
TBool CScreensaverIndicatorArray::Dependency(TInt aIndex) const
    {
    return (*iDependencyRecord)[aIndex];
    }
// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::Setup
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::Setup( TAknLayoutRect& aLayoutRect,
        TAknLayoutText& aLayoutText, TAknLayoutRect& aLayoutInds )
    {
    // Reset drawing parameters (do not use those defined in resources)
    iRect = aLayoutRect.Rect();

    TInt rightMargin = 0;
    // Left margin = indicators left edge - indicator area left edge
    // Right margin = 0, the AM/PM indicator needs to be on the edge
    // Except when mirrored the other way around. Right margin can be reduced
    // by 1 when mirrored, because the icons contain a border on top & right 
    if ( AknLayoutUtils::LayoutMirrored() )
        {
        iMargin = 0;
        rightMargin = aLayoutInds.Rect().iTl.iX - iRect.iTl.iX - 1;
        }
    else
        {
        iMargin = aLayoutInds.Rect().iTl.iX - iRect.iTl.iX;
        rightMargin = 0;
        }

    TInt currentX = iRect.iBr.iX - rightMargin;

    TInt leftmostRightAlignedBorder = iRect.iBr.iX - rightMargin; // iMargin;

    // This is done in two passes, first we set up right-aligned indicators
    // and then left-aligned. If any left-aligned indicator overlaps with leftmost
    // right-aligned indicator the the process is stopped (right-aligned
    // indicators have higher priority).
    for ( TInt i = 0; i < iIndicators->Count(); i++ )
        {
        if (iIndicators->At(i)->Alignment() != ESsAlignRight)
            {
            continue;
            }
        
        SetIndicatorsAttribute( i, aLayoutText, aLayoutInds, currentX );

        if (iIndicators->At(i)->Visible())
            {
            currentX -= iIndicators->At(i)->Width() + iGap;
            leftmostRightAlignedBorder = currentX;
            if (currentX < iMargin)
                {
                break;
                }
            }
        }

    // Start second round from left edge
    currentX = iRect.iTl.iX + iMargin;
    for ( TInt i = 0; i < iIndicators->Count(); i++ )
        {
        if (iIndicators->At(i)->Alignment() != ESsAlignLeft)
            {
            continue;
            }
        
        SetIndicatorsAttribute( i, aLayoutText, aLayoutInds, currentX );

        if (iIndicators->At(i)->Visible())
            {
            if (currentX + iIndicators->At(i)->Width() + iGap >= leftmostRightAlignedBorder)
                {
                iIndicators->At(i)->SetVisibility(EFalse);
                break;
                }
            currentX += iIndicators->At(i)->Width() + iGap;
            if (currentX > iRect.Width() - iMargin)
                {
                break;
                }
            }
        }
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::SetIndicatorsAttribute
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::SetIndicatorsAttribute( 
        TInt& Ind,
        TAknLayoutText& aLayoutText,
        TAknLayoutRect& aLayoutInds,
        TInt& aCurrentX )
    {

    // Set text layout for text containing indicators
    iIndicators->At(Ind)->SetTextLayout(aLayoutText, aCurrentX);

    // Set icon layout for icon containing indicators
    iIndicators->At(Ind)->SetIconLayout(aLayoutInds, aCurrentX);

    // Not visible, if conditions (e.g. there's icon & payload) are not met,
    // or there's no reason to show the indicator
    if (!iIndicators->At(Ind)->CheckVisibilityConditions() || Dependency(iIndicators->At(Ind)->Id()))
        {
        iIndicators->At(Ind)->SetVisibility(EFalse);        
        }
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::Draw
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::Draw(CWindowGc& aGc) const
    {
    aGc.SetBrushColor(iBgColor);
    aGc.SetPenColor(iTextColor);
    aGc.Clear(iRect);

    for (TInt i = 0; i < iIndicators->Count(); i++)
        {
        if (iIndicators->At(i)->Visible())
            {
            iIndicators->At(i)->Draw(aGc);
            }
        }
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::CheckDependencyConflict
// -----------------------------------------------------------------------------
//
TBool CScreensaverIndicatorArray::CheckDependencyConflict(
        TScreensaverIndicatorId aId) const
    {
    if ((iDependencyRecord) && (aId < iCount))
        {
        return Dependency(aId);
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::SetDependencyStatus
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::SetDependencyStatus(
        TScreensaverIndicatorId aId, TBool aValue)
    {
    if ((iDependencyRecord) && (aId < iCount))
        {
        (*iDependencyRecord)[aId] = aValue;
        }
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::GetIndicatorPayload
// -----------------------------------------------------------------------------
//
TInt CScreensaverIndicatorArray::GetIndicatorPayload(
        TScreensaverIndicatorId aId, TIndicatorPayload& aPayload) const
    {
    if (aId < iCount)
        {
        for (TInt i = 0; i < iIndicators->Count(); i++)
            {
            if (aId == iIndicators->At(i)->Id())
                {
                iIndicators->At(i)->Payload(aPayload);
                return KErrNone;
                }
            }
        }

    return KErrCorrupt;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::SetIndicatorPayload
// -----------------------------------------------------------------------------
//
TInt CScreensaverIndicatorArray::SetIndicatorPayload(
        TScreensaverIndicatorId aId, const TIndicatorPayload& aPayload)
    {
    if (aId < iCount)
        {
        for (TInt i = 0; i < iIndicators->Count(); i++)
            {
            if (aId == iIndicators->At(i)->Id())
                {
                iIndicators->At(i)->SetPayload(aPayload);
                return KErrNone;
                }
            }
        }

    return KErrCorrupt;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::PreferredDrawingMode
// -----------------------------------------------------------------------------
//
TScreensaverDrawType CScreensaverIndicatorArray::PreferredDrawingMode() const
    {
    TScreensaverDrawType result = ESsDrawTypeNotDrawn; // Default mode.

    for (TInt i = 0; i < iIndicators->Count(); i++)
        {
        if ((iIndicators->At(i)->CheckVisibilityConditions() == EFalse)
                || (CheckDependencyConflict(iIndicators->At(i)->Id())))
            {
            // This indicator can't be visible or there is 
            // dependency conflict -> continue.
            continue;
            }

        switch (iIndicators->At(i)->DrawType())
            {
            case ESsDrawTypePrimary:
                // Primary draw type overides everything,
                // so we can return immediately. 
                return ESsDrawTypePrimary;
            case ESsDrawTypeSecondary:
                result = ESsDrawTypeSecondary;
                break;
            default:
                break;
            }
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::ActualDrawingMode
// -----------------------------------------------------------------------------
//
TScreensaverDrawType CScreensaverIndicatorArray::ActualDrawingMode() const
    {
    TScreensaverDrawType result = ESsDrawTypeNotDrawn; // Default mode.
    
    for (TInt i = 0; i < iIndicators->Count(); i++)
        {
        if ((iIndicators->At(i)->CheckVisibilityConditions() == EFalse)
                || !( iIndicators->At(i)->Visible() ) )
            {
            // This indicator can't be visible or it is visible
            continue;
            }
        
        switch (iIndicators->At(i)->DrawType())
            {
            case ESsDrawTypePrimary:
                return ESsDrawTypePrimary; // Primary draw type overides everything.
            case ESsDrawTypeSecondary:
                result = ESsDrawTypeSecondary;
                break;
            default:
                break;
            }
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::Height
// -----------------------------------------------------------------------------
//
TInt CScreensaverIndicatorArray::Height() const
    {
    return iHeight;
    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::SetVisibilityForIndicators
// -----------------------------------------------------------------------------
//
void CScreensaverIndicatorArray::SetVisibilityForIndicators()
    {
    for (int i = 0; i < iIndicators->Count(); i++)
        {
        // Not visible, if conditions (e.g. there's icon & payload) are not met,
        // or there's no reason to show the indicator
        if (!iIndicators->At(i)->CheckVisibilityConditions() || Dependency(iIndicators->At(i)->Id()))
            {
            iIndicators->At(i)->SetVisibility(EFalse);
            }
        else
            iIndicators->At(i)->SetVisibility(ETrue);
        }

    }

// -----------------------------------------------------------------------------
// CScreensaverIndicatorArray::CScreensaverIndicatorArray
// -----------------------------------------------------------------------------
//
CScreensaverIndicatorArray::CScreensaverIndicatorArray()
    {
    
    }

// End of files