/*

* Copyright (c) 2009 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: 

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32cons.h>

#include <e32svr.h>

#include <utf.h>

#include <apgtask.h>

#include "atconsoleui.h"

#include "atconsoleviews.h"

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void LimitedAppend( TDes& aOriginal, const TDesC& aAppend);

// FORWARD DECLARATIONS

// ==================== LOCAL FUNCTIONS =======================================

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

// LimitedAppend()

// Appends texts.

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

//

LOCAL_C void LimitedAppend( TDes& aOriginal, const TDesC& aAppend )

    {

    TInt spaceLeft = aOriginal.MaxLength() - aOriginal.Length();

    if ( spaceLeft > aAppend.Length() )

        {

        aOriginal.Append ( aAppend );

        }

    else

        {       

        aOriginal.Append ( aAppend.Left ( spaceLeft ) );

        }

    }

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

// CView::NewL()

// First phase constructor.

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

//

CView* CView::NewL( CConsoleMain* aConsole,

                    CView* aParent,

                    const TDesC& aName,

                    TInt64 aProcessId

                  )

    {

    CView* self = new ( ELeave ) CView();

    CleanupStack::PushL( self );

    self->ConstructL( aConsole, aParent, aName, aProcessId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CView::ConstructL()

// Second phase constructor.

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

//

void CView::ConstructL( CConsoleMain* aConsole,

                        CView* aParent,

                        const TDesC& aName, TInt64 aProcessId

                      )

    {

    // Store the parameters

    iMain = aConsole;

    iConsole = aConsole->GetConsole();

    iParent = aParent;

    iViewName = aName;

    iProcessId = aProcessId;

    // Get display size

    const TInt KOverHead = 5;

    iSize = iConsole->ScreenSize();

    iScreenSize = iSize.iHeight - KOverHead;   // Size available for menus

    }

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

// CView::CView()

// C++ default constructor.

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

//

CView::CView()

    {

    iDirection = 1;

    iPrevPos  = -1;     // Invalid starting value

    }

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

// CView::~CView()

// Destructor.

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

//

CView::~CView()

    {    

    iItems.ResetAndDestroy();

    }

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

// CView::TimerUpdate()

// Handles screen updates.

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

//

void CView::TimerUpdate()

    {   

    RArray<TDesC> texts;

    if( ItemTexts( texts ) != KErrNone )

        {

        texts.Close();

        return;

        }

    TInt count = texts.Count();

    // If list is empty, do not scroll.

    if ( count < 1 )

        {

        texts.Close();

        return;

        }

    else if( iFirstItem + iPositionOnScreen > count )

        {

        iFirstItem = iPositionOnScreen = 0;

        }

    // If menu selection is updated, then restart scrolling

    if (iPrevPos != iFirstItem + iPositionOnScreen)

        {

        iPrevPos = iFirstItem + iPositionOnScreen;

        iStart = 0;

        iDirection = 1;

        }

    // If menu item have not been changed after last timer, then

    // start scrolling  

    const TDesC& name = texts[ iFirstItem + iPositionOnScreen ]; 

    if ( name.Length() > iSize.iWidth)

        {

        TInt y = iConsole->WhereY();

        TInt x = iConsole->WhereX();

        TBuf<80> iTmp;

        iStart = iStart + iDirection;

        // "Right end"

        if ( iStart + iSize.iWidth > name.Length() + KViewOverhead )

            {

            iStart--;

            iDirection = -1;

            }

        // "Left end"

        if ( iStart == -1 )

            {

            iStart++;

            iDirection = 1;

            }

        if( iStart > name.Length() )

            {

            iStart = 0;

            }

        iTmp=_L(" *");

        LimitedAppend( iTmp, name.Mid ( iStart ) );

        iConsole->SetPos( 0, iPositionOnScreen + 1 );

        iConsole->Printf ( iTmp.Left( iSize.iWidth -2 )  );

        iConsole->SetPos(x,y);

        }

    texts.Close();

    }

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

// CView::AppendBefore()

// Appends cursor to the line.

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

//

void CView::AppendBefore( TInt aLineNum, TDes& aLine )

    {    

    if( ( aLine.MaxLength() - aLine.Length() ) < 2 )

        {

        return;

        }        

    // If printing active line, print the marker

    if ( aLineNum == iPositionOnScreen + iFirstItem )

        {

        aLine.Append( _L(" *") );

        }

    else

        {

        aLine.Append( _L("  ") );

        }        

    }

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

// CView::PrintViewL()

// Prints view.

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

//

void CView::PrintViewL( TUpdateType aType )

    {

    iUpdateType = aType;

    TBuf<KMaxLineLength> line;

    // Clear display

    iConsole->ClearScreen();

    // Print menu title

    Print( Name() );

    RArray<TDesC> texts;

    if( ItemTexts( texts ) != KErrNone )

        {

		texts.Close();

        return;

        }

    TInt oldItemCount = iItemCount;

    iItemCount = texts.Count();

    // If first time in menu, update start and end positions

    if( ( iFirstItem == iLastItem ) ||        // First time here..

        ( iLastItem >= iItemCount ) ||

        ( oldItemCount != iItemCount ) )      // Menu size changed

        {

        iLastItem = iItemCount - 1;

        iPositionOnScreen = 0;

        // If "overflow", then adjust the end

        if (iLastItem > iScreenSize )

            {

            iLastItem = iScreenSize;

            }

        }

    // Print items

    for ( TInt i = iFirstItem; i <= iLastItem; i++ )

        {

        line.Zero();

        // Append text before line

        AppendBefore( i, line );

        TBuf<2*KMaxName> temp;

        if ( i < iItems.Count() )

            {

            temp.Copy( iItems[ i ]->Name() );

            TATLogOption loggingMode;

            iMain->StorageServer().GetLoggingModeL( iMain->Processes()[ i ].iProcessId, loggingMode );

            if ( EATLoggingOff != loggingMode )

                {

                if ( iMain->IsSubTestRunning( iMain->Processes()[ i ].iProcessId ) > KErrNotFound )

                    {

                    temp.Append( _L(": ") );

                    temp.Append( _L("subtest running") );

                    }                   

                }

            else

                {

                temp.Append( _L(": ") );

                temp.Append( _L("logging cancelled") );

                }

            // TEST START

            /*if ( i == iFirstItem )

                {

                temp.Append( _L(": ") );

                temp.Append( _L("subtest running") );

                }

            else if ( i == iFirstItem + 1 )

                {

                temp.Append( _L(": ") );

                temp.Append( _L("logging cancelled") );

                }

            else if ( i == iFirstItem + 2 )

                {

                temp.Append( _L(": ") );

                temp.Append( _L("subtest running") );

                }*/

            // TEST END

            LimitedAppend ( line, temp /*texts[i]*/ );

            }

        else

            LimitedAppend ( line, KExitTxt );

        // Print the line

        Print(line);

        }

    texts.Close();

    }

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

// CView::SelectL()

// Handles line selections.

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

//

CView* CView::SelectL( TKeyCode aSelection, TBool& aContinue )

    {

    MapKeyCode( aSelection );

    switch ( ( TInt )aSelection )

        {

        // Exit

        case EKeyEscape:

            aContinue = EFalse;

            return this;

        // SelectL item

        case EKeyEnter:

        case EKeyRightArrow:

            {

            // Print items

            for ( TInt i = iFirstItem; i <= iLastItem; i++ )

                {

                if ( i < iItems.Count() )

                    {

                    TATLogOption loggingMode;

                    TInt processCount ( iMain->Processes().Count() );

                    if ( i <  processCount )

                        {

                        iMain->StorageServer().GetLoggingModeL( iMain->Processes()[ i ].iProcessId, loggingMode );

                        if ( EATLoggingOff != loggingMode )

                            {

                            return iItems[ iPositionOnScreen ];

                            }

                        else

                            {

                            return this;

                            }

                        }

                    }

                }                    

            //return iItems[ iPositionOnScreen ];

            } 

        // Going back

        case EKeyLeftArrow:

            {

            TBool tmp = iShowLibraries | iSetLoggingMode;

            iShowLibraries = EFalse;

            iSetLoggingMode = EFalse;

            if ( tmp )

                return this;

            else

                return iParent;

            }

        // Go down

        case EKeyDownArrow:

            {

            if ( iFirstItem + iPositionOnScreen == iItemCount - 1 )

                {

                // If end of the list, go to beginning

                iLastItem = iLastItem - iFirstItem;

                iFirstItem = 0;

                iPositionOnScreen = 0;

                }

            else 

                {

                if ( iPositionOnScreen == iScreenSize )

                    {

                    // If in end of screen, update items

                    if ( iLastItem != ( iItemCount - 1 ) )

                        {

                        // If not end of the list, then update first and last

                        // but do not update position in screen.

                        iLastItem++;

                        iFirstItem++;

                        }

                    }

                else

                    {

                    // Going down "in-screen", no need to update items

                    iPositionOnScreen++;

                    }

                }

            break;

            }   

        // Go Up

        case EKeyUpArrow:

            {

            if ( iFirstItem + iPositionOnScreen == 0 )

                {

                // If in the beginning of the list

                if ( iItemCount <= iScreenSize ) 

                    {

                    // Wrap around when the list is not full

                        iPositionOnScreen = iItemCount-1;

                    }

                else

                    {

                    // Wrap around when there are more items than

                    // can be shown at once.            

                    iPositionOnScreen = iScreenSize;

                    iLastItem = iItemCount-1;

                    iFirstItem = iItemCount - iPositionOnScreen - 1;

                    }

                }

            else if ( iPositionOnScreen == 0 )

                {

                // If not at the beginning of the list, then update first and

                // last  but do not update position in screen.

                if ( iFirstItem != 0 )

                    {

                    iLastItem--;

                    iFirstItem--;

                    }

                }

            else

                {

                // Going up "in-screen", no need to update items

                iPositionOnScreen--;

                }

            break;

            }                

        // Additional keys

        case EKeyHome:

        case '3':

            iPositionOnScreen = 0;

            iFirstItem = 0;

            iLastItem = iScreenSize;

            if ( iLastItem > iItemCount-1 )

                {

                iLastItem = iItemCount-1;

                }

            break;

        case EKeyEnd:

        case '9':

            iPositionOnScreen = iScreenSize;

            iLastItem = iItemCount-1;

            iFirstItem = iLastItem - iScreenSize;

            if ( iFirstItem < 0 )

                {

                iFirstItem = 0;

                iPositionOnScreen = iLastItem-1;

                }

            break;

        case EKeyPageUp:

        case '1':

            iFirstItem = iFirstItem - iScreenSize - 1;

            iLastItem = iLastItem - iScreenSize - 1;

            if ( iFirstItem < 0 )

                {

                iFirstItem = 0;

                iPositionOnScreen = 0;

                iLastItem = iScreenSize;

                if ( iLastItem > iItemCount-1 )

                    {

                    iLastItem = iItemCount-1;

                    }

                }

            break;

        case EKeyPageDown:

        case '7':

            iFirstItem = iFirstItem + iScreenSize + 1;

            iLastItem = iLastItem + iScreenSize + 1;

            // Going too far

            if ( iLastItem > iItemCount - 1 )

                {

                iLastItem = iItemCount-1;

                iFirstItem = iLastItem - iScreenSize;

                iPositionOnScreen = iScreenSize;

                }

            // Ok, list is smaller than screen

            if ( iFirstItem < 0 )

                {

                iFirstItem = 0;

                iLastItem = iItemCount-1;

                iPositionOnScreen = iLastItem;

                }

            break;

        default:  // Bypass the keypress

            break;

        }

    // Continue normally and keep in the same menu

    aContinue = ETrue;

    return this;

    }

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

// CView::ItemTexts()

// Formats menu texts

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

//

TInt CView::ItemTexts( RArray<TDesC>& aArray )

    {

    TInt count = iItems.Count();

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

        {

        TBuf<50> temp;

        temp.Copy( iItems[i]->Name() );

        if( aArray.Append( iItems[i]->Name() ) != KErrNone )

            {

            return KErrNoMemory;

            }

        }

    return KErrNone;

    }