/*

* 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 "SGMainContainer.h"

#include <AknBidiTextUtils.h>

#include <AknUtils.h>

#include <aknnotewrappers.h>

#include <eiksbfrm.h>

#include <AknsDrawUtils.h> 

#include <AknsBasicBackgroundControlContext.h>

#include <akntitle.h>

#include <eikspane.h>  

#include <AknDef.h>

const TUint KLeftMargin = 2;

const TUint KRightMargin = 2;

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

void CScreenGrabberMainContainer::ConstructL(const TRect& aRect)

    {

    iSkinContext = NULL;

    CreateWindowL();

    Window().SetShadowDisabled(EFalse);

    SetBlank();

    // set title of the app

    CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();

    CAknTitlePane* title = static_cast<CAknTitlePane*>( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    title->SetTextL( _L("Screen Grabber") );

    iText = HBufC::NewL(200000);

    iCurrentLine = 0;

    iLineCount = 0;

    iNumberOfLinesFitsScreen = 0;

    iX_factor = 1;

    iY_factor = 1;

    iLeftDrawingPosition = KLeftMargin;

    // get font

    iFont = AknLayoutUtils::FontFromId(EAknLogicalFontSecondaryFont);

    iWrappedArray = new(ELeave) CArrayFixFlat<TPtrC>(500);

    SetRect(aRect);

    ActivateL(); 

    PrintText(_L("Please use the settings screen to define the capture mode and any other related settings such capture hotkey and saving format. Using the PNG format for screen shots is recommended, since it is compressed but lossless. The captures can be managed with the Media Gallery application.\n\nYou may start taking screenshots or capturing video now. Please press the Applications key to go back to the Application menu or send this application to the background via the Options menu. To be able to take screenshots or capture video, this applications needs to stay running in the background.\n"));

    }

CScreenGrabberMainContainer::~CScreenGrabberMainContainer()

    {

    if (iSkinContext)

    	delete iSkinContext;

	if (iWrappedArray)

		{

    	iWrappedArray->Reset();

    	delete iWrappedArray;

		}

	if (iText)

    	delete iText;

    if (iScrollBarFrame)

        delete iScrollBarFrame;

    if (iWrapperString)

        delete iWrapperString;

    }

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

// CScreenGrabberMainContainer::UpdateVisualContentL()

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

//

void CScreenGrabberMainContainer::UpdateVisualContentL(TBool aScrollToBottom)

    {

    TSize rectSize;

    AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EMainPane, rectSize);

    TRect rect(rectSize);

    // set the correct drawing area for the skin background

    if(iSkinContext)

        {

        delete iSkinContext;

        iSkinContext = NULL;

        }  

    iSkinContext = CAknsBasicBackgroundControlContext::NewL(KAknsIIDQsnBgAreaMain, rectSize, EFalse);

    // init scroll bar if not yet done

    if (!iScrollBarFrame)

        {

        iScrollBarFrame = new(ELeave) CEikScrollBarFrame(this, this, ETrue);

        CAknAppUi* appUi = iAvkonAppUi;

	    if (AknLayoutUtils::DefaultScrollBarType(appUi) == CEikScrollBarFrame::EDoubleSpan)

	        {

		    iScrollBarFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse);            

		    iScrollBarFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan);

	        }

	    else

	        {

		    iScrollBarFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EArrowHead);

	        }  

	    iScrollBarFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        }

    // drawing positions, needed for scalable ui

    iX_factor = TReal(rect.Width()) / 176;

    iY_factor = TReal(rect.Height()) / 144;

    iWrappedArray->Reset();

    if (iWrapperString)

        {

        delete iWrapperString;

        iWrapperString = NULL;

        }

    // define drawing width, some extra space needed if using double span scrolling bar

    TUint drawingWidth(0);

    if (iScrollBarFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan)

        {

        if (AknLayoutUtils::LayoutMirrored())  // scroll bar on 'left'

            {

            iLeftDrawingPosition = KLeftMargin + 12;

            drawingWidth = TInt( rect.Width() - iLeftDrawingPosition*iX_factor - (KRightMargin*iX_factor)); 

            }

        else // scroll bar on 'right'

            {

            iLeftDrawingPosition = KLeftMargin;  

            drawingWidth = TInt( rect.Width() - iLeftDrawingPosition*iX_factor - (KRightMargin*iX_factor + 7*iX_factor)); 

            }        

        }

    else

        drawingWidth = TInt( rect.Width() - KLeftMargin*iX_factor - KRightMargin*iX_factor);

    // wrap the text

    iWrapperString = AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(

        iText->Des(),

        drawingWidth,

        *iFont,

        *iWrappedArray

        );

    iLineCount = iWrappedArray->Count();

    // count amount of lines fits to screen

    iNumberOfLinesFitsScreen = TInt(rect.Height() / (iFont->HeightInPixels()));

    // check if needed to scroll to the bottom

    if (aScrollToBottom && iCurrentLine < iLineCount - iNumberOfLinesFitsScreen)

        {

        iCurrentLine = iLineCount-iNumberOfLinesFitsScreen;

        }

    // update the scroll bars

	TEikScrollBarModel horizontalBar;

    TEikScrollBarModel verticalBar;

    verticalBar.iThumbPosition = iCurrentLine;

    verticalBar.iScrollSpan = iLineCount - iNumberOfLinesFitsScreen + 1;

    verticalBar.iThumbSpan = 1;

    TEikScrollBarFrameLayout layout;

	layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant;

    if (iScrollBarFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan)

        {    

        // do not let scrollbar values overflow

        if (verticalBar.iThumbPosition + verticalBar.iThumbSpan > verticalBar.iScrollSpan)

            verticalBar.iThumbPosition = verticalBar.iScrollSpan - verticalBar.iThumbSpan;

        TAknDoubleSpanScrollBarModel horizontalDSBar(horizontalBar);

        TAknDoubleSpanScrollBarModel verticalDSBar(verticalBar);

        iScrollBarFrame->TileL(&horizontalDSBar, &verticalDSBar, rect, rect, layout);        

        iScrollBarFrame->SetVFocusPosToThumbPos(verticalDSBar.FocusPosition());

	    }  

	else

	    {

		iScrollBarFrame->TileL( &horizontalBar, &verticalBar, rect, rect, layout );

		iScrollBarFrame->SetVFocusPosToThumbPos( verticalBar.iThumbPosition );

	    }

    // update the screen

    DrawNow();

    }

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

// CScreenGrabberMainContainer::Draw(const TRect& aRect) const

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

//

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

    {

    CWindowGc& gc = SystemGc();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if (iSkinContext)

	    {

        // draws the skin background

	    AknsDrawUtils::Background(skin, iSkinContext, this, gc, aRect);

	    }

    else

        {

        gc.Clear(aRect);

        }

    // get the text color from the skin   

    TRgb skinPenColor;

    if (AknsUtils::GetCachedColor( skin, skinPenColor, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6 ) == KErrNone)

        {

		gc.SetPenColor(skinPenColor);

		}	

    else

        {

        gc.SetPenColor(KRgbBlack);

        }

    gc.UseFont(iFont);

    // draw the text

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

        {

        // index out of bounds check and then draw text

        if (i+iCurrentLine < iWrappedArray->Count())

            gc.DrawText(iWrappedArray->At(i+iCurrentLine), TPoint(TInt(iLeftDrawingPosition*iX_factor), TInt(iFont->HeightInPixels()*(i+1))));

        }

    gc.DiscardFont();

    }

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

// CScreenGrabberMainContainer::HandleControlEventL(

//     CCoeControl* aControl,TCoeEvent aEventType)

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

//

void CScreenGrabberMainContainer::HandleControlEventL(

    CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)

    {

    }

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

// CScreenGrabberMainContainer::PrintText(const TDesC& aDes)

// Print text into output window.

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

//

void CScreenGrabberMainContainer::PrintText(const TDesC& aDes)

    {

    iText->Des().Append( aDes );

    UpdateVisualContentL(EFalse);  // do not automatically scroll to the bottom

    }

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

// CScreenGrabberMainContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,

//                                    TEventCode aType)

// Handle key event. Only up and down key arrow events are

// consumed in order to enable scrolling in output window.

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

//

TKeyResponse CScreenGrabberMainContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    {

    if(aType != EEventKey)

        return EKeyWasNotConsumed;

    if(aKeyEvent.iCode == EKeyUpArrow)

        {

        if (iCurrentLine > 0)

            {

            iCurrentLine--;

            UpdateVisualContentL(EFalse);

            }

        return EKeyWasConsumed;

        }

    else if(aKeyEvent.iCode == EKeyDownArrow)

        {

        if (iCurrentLine < iLineCount - iNumberOfLinesFitsScreen)

            {

            iCurrentLine++;

            UpdateVisualContentL(EFalse);

            }

        return EKeyWasConsumed;

        }

    return EKeyWasNotConsumed;

    }

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

// CScreenGrabberMainContainer::ClearOutputWindow()

// Clear the output window.

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

//

void CScreenGrabberMainContainer::ClearOutputWindow()

    {

    iText->Des() = _L("");

    UpdateVisualContentL(ETrue);

    }

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

// CScreenGrabberMainContainer::HandleResourceChange(TInt aType)

// Handle layout change of the screen

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

//

void CScreenGrabberMainContainer::HandleResourceChange(TInt aType)

    {

    if (aType == KEikDynamicLayoutVariantSwitch || aType == KAknsMessageSkinChange)

        {

        TRect mainPaneRect;

        AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);

        SetRect(mainPaneRect);

        iCurrentLine = 0; // scroll to top

        // update font

        iFont = AknLayoutUtils::FontFromId(EAknLogicalFontSecondaryFont);

        // delete the scroll and update screen

        if (iScrollBarFrame)

            {

            delete iScrollBarFrame;

            iScrollBarFrame = NULL;

            }

        UpdateVisualContentL(EFalse);

        }

    else

        {

        CCoeControl::HandleResourceChange(aType);

        }

    }

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

// CScreenGrabberMainContainer::MopSupplyObject(TTypeUid aId)

// Pass skin information if needed

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

//

TTypeUid::Ptr CScreenGrabberMainContainer::MopSupplyObject(TTypeUid aId)

    {

    if (aId.iUid == MAknsControlContext::ETypeId && iSkinContext)

        {

        return MAknsControlContext::SupplyMopObject(aId, iSkinContext);

        }

    return CCoeControl::MopSupplyObject(aId);

    }

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

// CScreenGrabberMainContainer::HandleScrollEventL()

// Capture touch events on the scroll bar

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

//

void CScreenGrabberMainContainer::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)

    {

    // only on page up/down,scroll up/down and drag events

    if ((aEventType == EEikScrollPageDown) || (aEventType == EEikScrollPageUp) || 

       (aEventType == EEikScrollThumbDragVert) || (aEventType == EEikScrollUp) ||

       (aEventType == EEikScrollDown))

        {

        // get the current position from the scroll bar

        iCurrentLine = aScrollBar->ThumbPosition();

        // refresh now

        UpdateVisualContentL(EFalse);

        }

    }

// End of File