* Copyright (c) 2002 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: application container control.  

*

*/

// INCLUDE FILES

#include "AboutContainer.h"

#include "AboutImage.h"

#include "about.hrh"

#include "about_test.hrh"

#include "AboutResourceLoader.h"

#include "AboutResource.h"

#include <layoutmetadata.cdl.h>

#include <about.rsg>

#include <about_oss_part_text.rsg>

#include <about_oss_other_text.rsg>

#include <eiksbfrm.h>

#include <eikscrlb.h>

#include <eikrted.h>

#include <txtrich.h>

#include <barsread.h>

#include <eikenv.h>

#include <aknenv.h>

#include <AknUtils.h>

#include <aknconsts.h>

#include <txtfrmat.h>

#include <AknBidiTextUtils.h>

#include <data_caging_path_literals.hrh>

#include <f32file.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknappui.h>

#include <AknsDrawUtils.h> 

#include <AknsBasicBackgroundControlContext.h>

#include <AknsConstants.h>

#include <AknDef.h>

#include <about.mbg>

#include <StringLoader.h> 

// CONSTANTS

const TInt KAboutOSSIndex = 14; // For adding blank break between OSS Text and real Text

_LIT( KAboutPanicCategory, "About" );

// Resource files for about application loading real data because this rsc file must be loaded by yourself

_LIT( KRSCDirAndFile, "Z:\\resource\\apps\\about_oss_part_text.rsc" );

_LIT( KRSCDirAndFileAdd, "Z:\\resource\\apps\\about_oss_other_text.rsc" );

enum TAboutPanic

    {

    EAboutNotSupported = 0

    };

/**

* SCROLLING:

*

* Scrolling is implemented according to the following rules

* when scrolling down:

*

* (same screens are shown again when scrolling up)

*

* - If the last line in previous screen was a text line,

*   next screen is started with that line, ie. the last

*   line is shown again in the next screen.

*

* - If previous screen ended with an image that did not

*   fully fit, next screen is started with that image so

*   that it can be seen as a whole.

*

* - If previous screen ended with an image that fit there fully,

*   next screen is started with next text line or image.

*/

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

// -----------------------------------------------------------------------------

// CAboutContainer::CAboutContainer()

// -----------------------------------------------------------------------------

CAboutContainer::CAboutContainer()

    {

    }

// -----------------------------------------------------------------------------

// CAboutContainer::ConstructL()

// -----------------------------------------------------------------------------

void CAboutContainer::ConstructL( const TRect& aRect )

    {

    CreateWindowL();

    iScrollBarDragged = EFalse;

    iBreakFlag = EFalse;

    iLoader = CAboutResourceLoader::NewL( iEikonEnv, this );

    ActivateL();

    }

// -----------------------------------------------------------------------------

// CAboutContainer::~CAboutContainer()

// -----------------------------------------------------------------------------

CAboutContainer::~CAboutContainer()

    {

    delete iSBFrame;

    delete iScreenStarts;

    delete iIcon;

    if ( iText )

        {

        iText->ResetAndDestroy();

        delete iText;

        }

    if ( iImages )

        {

        iImages->ResetAndDestroy();

        delete iImages;

        }

    if ( iLoader )

        {

        iLoader->Cancel();

        delete iLoader;

        iLoader = NULL;

        }

    }

// -----------------------------------------------------------------------------

// CAboutContainer::SizeChanged()

// -----------------------------------------------------------------------------

void CAboutContainer::SizeChanged()

    {

        {

        }

// -----------------------------------------------------------------------------

// CAboutContainer::Draw()

// -----------------------------------------------------------------------------

void CAboutContainer::Draw( const TRect& aRect ) const

    {

    CWindowGc& gc = SystemGc();

		{

		//Draw the skin background

		AknsDrawUtils::Background(

		}

	else

		{//  clear the area

		gc.SetBrushColor( iEikonEnv->ControlColor( EColorWindowBackground, *this ) );

		gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

		gc.Clear( aRect );

		}

    // draw text

    gc.UseFont( iFont );

    // index of the first line on the screen in the text array

    TInt firstLine = 0 ;

    // The value of firstLine can not be the same.

    if ( !iScrollBarDragged )

        {

        if ( ( iScreenStarts ) && (iScreenStarts->Count() >= iCurrentScreen ) )

            {

            }        

        }

    else

        {                    

        if ( iCurrentScreen <= ( ( *iScreenStarts )[ iScreenStarts->Count() - 1 ] ) )

            {

            firstLine = iCurrentScreen ;

            }

        }

    // index of the last line on the screen in the text array

    TInt lastLine( firstLine + iLinesPerScreen - 1 );

    gc.SetBrushStyle( CGraphicsContext::ENullBrush );

    TPoint position( iTopBaseLineX, iTopBaseLineY );

    TPoint topLeft;

    TSize rectSize( iLineWidth, iBaseLineDelta +iFont->DescentInPixels() );

    for ( TInt index = firstLine ;

          index < iText->Count() && index <= lastLine ;

          index++, position.iY += iBaseLineDelta )

        {

        HBufC* text = (*iText)[ index ];

        if ( text )

            {

            topLeft = TPoint( position.iX, position.iY-iBaseLineDelta );

			TRgb color;			

			TInt error = AknsUtils::GetCachedColor( skin, 

							color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6 );

				{

				}		

            gc.DrawText( *text,

                         TRect( topLeft, rectSize ),

                         iBaseLineDelta,

                         iTextAlign );

            }

        }

    gc.DiscardFont();

    // draw images

    for ( TInt i = 0 ; i < iImages->Count() ; i++ )

        {

        CAboutImage* image = (*iImages)[ i ];

        // If part of the image resides in visible lines, draw it.

        if ( image->StartLine() <= lastLine && image->EndLine() >= firstLine )

            {

            position.SetXY( iTopBaseLineX, iTopBaseLineY );

            position.iY += ( image->StartLine() - firstLine ) * iBaseLineDelta;

            position.iY -= iBaseLineDelta - iFont->DescentInPixels();

            // Now iY is the top line of rectangle where the picture is

            // centered in.

                             iFont->HeightInPixels() -

                             image->HeightInPixels() ) / 2;

            // If text is right-aligned, also align images to the right.

            if ( iTextAlign == CGraphicsContext::ERight )

                {

                position.iX += ( iLineWidth - image->WidthInPixels() );

                }

            // Draw javalogo on Screeen (PictureType: svg)

            gc.BitBltMasked( position, image->Bitmap(), aRect, 

                    image->BitmapMask(), ETrue );

            }

        }

    }

// -----------------------------------------------------------------------------

// CAboutContainer::ActivateL()

// -----------------------------------------------------------------------------

void CAboutContainer::ActivateL()

    {

    CCoeControl::ActivateL();

    UpdateScrollIndicatorL();

    }

// -----------------------------------------------------------------------------

// CAboutContainer::SetTextL()

// -----------------------------------------------------------------------------

void CAboutContainer::SetTextL( const TDesC& aText , const TInt aItem )

    {

    CArrayFix<TPtrC>* wrappedArray =

        new( ELeave ) CArrayFixFlat<TPtrC>( 10 );

    CleanupStack::PushL( wrappedArray );

    HBufC* dataToDestroy =

        AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(

            aText, iLineWidth, *iFont, *wrappedArray

        );

    TInt numLines( wrappedArray->Count() );

    for ( TInt i = 0 ; i < numLines ; i++ )

        {

        HBufC* line = (*wrappedArray)[i].AllocLC();

		switch( aItem )

			{

			// Between About real text and oss text

			case KAboutOSSIndex:

				{

				iBreakFlag = ETrue;

				break;

				}

			default:

				break;

			}

            {

            iText->AppendL( NULL );

            }

        else

            {

            if( iBreakFlag && ( numLines - 1 ) == i )

            	{

                iText->AppendL( line );

                // Get the text's lines' count for set break

                TInt textCount = iText->Count();

                TInt count = iLinesPerScreen - ( textCount % ( iLinesPerScreen - 1 ) ) - 1;

                if( iLinesPerScreen == count + 1 )

                	{

                	// When the last line has content, we should set count zero 

                	count = 0;

                	}

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

                	{

                	iText->AppendL( NULL );

                	}

                CleanupStack::Pop( line );  // line

                iBreakFlag = EFalse;

            	}

            else

            	{

                iText->AppendL( line );

                CleanupStack::Pop( line );  // line

            	}

            }

        }

	iText->AppendL( NULL );

    // If the last char was newline, add one extra, since

    // wrapping automatically removes it.

    if ( aText[ aText.Length() - 1 ] == '\n' )

        {

        iText->AppendL( NULL );

		}

    delete dataToDestroy;

    // update screen scrolling info array

    TInt lastLine( iText->Count() - 1 );

    TInt screenStart( (*iScreenStarts)[ iScreenStarts->Count() - 1 ] );

    TBool firstNewScreenHandled( EFalse );

    while ( lastLine >= screenStart + iLinesPerScreen )

        {

        if ( !firstNewScreenHandled && iDoNotShowLastLineAgain )

            {

            screenStart++;

            firstNewScreenHandled = ETrue;

            }

        screenStart += iLinesPerScreen - 1;

        iScreenStarts->AppendL( screenStart );

        if ( ( lastLine == screenStart + 1 ) && ( aItem == iLoader->ItemCount() - 1 ) )

        	{

        	iScreenStarts->Delete( iScreenStarts->Count() - 1 );

        	}

        }

    // if text, last line is shown again in next screen

    iDoNotShowLastLineAgain = EFalse;

    }

// -----------------------------------------------------------------------------

// CAboutContainer::SetImageL()

// -----------------------------------------------------------------------------

void CAboutContainer::SetImageL( const TDesC& aFileName, TInt aBitmapId )

    {

    TInt firstLineOfImage( iText->Count() );

    // If flag is ETrue, the file type is bmp 

    CAboutImage* image =

    CAboutImage::NewLC( aFileName, aBitmapId, firstLineOfImage, iBaseLineDelta,

            EFalse );

    // new lines to make room for the picture

    for ( TInt i = 0 ; i < image->Lines() ; i++ )

        {

        iText->AppendL( NULL );

        }

    iImages->AppendL( image );

    // update screen scrolling info array

    TInt lastLineOfImage( iText->Count() - 1 );

    TInt screenStart( (*iScreenStarts)[ iScreenStarts->Count() - 1 ] );

    TBool firstNewScreenHandled( EFalse );

    // If the image was not fully shown in the first screen,

    // start the next screen with the image.

    if ( firstLineOfImage < screenStart + iLinesPerScreen &&

         lastLineOfImage >= screenStart + iLinesPerScreen )

        {

        screenStart = firstLineOfImage;

        iScreenStarts->AppendL( screenStart );

        firstNewScreenHandled = ETrue;

        }

    while ( lastLineOfImage >= screenStart + iLinesPerScreen )

        {

        if ( !firstNewScreenHandled && iDoNotShowLastLineAgain )

            {

            screenStart++;

            firstNewScreenHandled = ETrue;

            }

        screenStart += iLinesPerScreen - 1;

        iScreenStarts->AppendL( screenStart );

        }

    if ( lastLineOfImage == screenStart + iLinesPerScreen - 1 )

        {

        iDoNotShowLastLineAgain = ETrue;

        }

    else

        {

        iDoNotShowLastLineAgain = EFalse;

        }

    }

// -----------------------------------------------------------------------------

// CAboutContainer::OfferKeyEventL()

// -----------------------------------------------------------------------------

TKeyResponse CAboutContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                              TEventCode aType )

    {

    // Operation is different in dragging and thumbing.

    if ( ( iScrollBarDragged ) && ( aType == EEventKey ) )

        {

        for( TInt i=0; i<iScreenStarts->Count(); i++ )

            {

            if ( iCurrentScreen <= ( ( *iScreenStarts )[i] ) ) 

                {

                // if last state is dragging, value of iCurrentScreen should be adjusted.

                switch ( aKeyEvent.iCode )

                    {

                    case EKeyUpArrow:

                        {

                        iScrollBarDragged = EFalse;

                        // Do nothing if the scroll bar is on the top, when pressing arrow up.

                        if ( i != 0 )

                            {

                            iCurrentScreen =  ( i - 1 );

                            }

                        DrawNow();

                        UpdateScrollIndicatorL();

                        break;

                        }

                    case EKeyDownArrow:

                        {

                        iScrollBarDragged = EFalse;

                        if ( ( iCurrentScreen == ( *iScreenStarts )[i] )

                            // Do nothing if the scroll bar is on the bottom, 

                            // when pressing arrow down.

                            && ( i != ( iScreenStarts->Count() - 1 ) ) )

                            {

                            iCurrentScreen = ( i + 1 );

                            }

                       	else

                            {

                            iCurrentScreen = i;

                            }

                        DrawNow();

                        UpdateScrollIndicatorL();

                        break;

                        }

                    default:

                        break;

                    }

                return EKeyWasConsumed;

                }

            } 

        }

    if ( aType == EEventKey && iScreenStarts->Count() > 1 )

        {

        switch ( aKeyEvent.iCode )

            {

            case EKeyUpArrow:

                {

                if ( iCurrentScreen > 0 )

                    {

                    iCurrentScreen--;

                    DrawNow();

                    UpdateScrollIndicatorL();

                    }

                }

                break;

            case EKeyDownArrow:

                {

                if ( iCurrentScreen < iScreenStarts->Count() - 1 )

                    {

                    iCurrentScreen++;

                    DrawNow();