/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 "minimap.h"

#include <fbs.h>

#include <gdi.h>

#include <bitstd.h>

#include <w32std.h>

#include <coecntrl.h>

#include "minimapgenerator.h"

#include "minimaptimer.h"

// MACROS

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KDefaultZoomOutPercent = 325; // 3.0x minimap zoom out by default

//const TInt KDefaultTransparency = 15; // % transparent

// This is the transparency that is the starting point in fade effect

const TInt KDefaultTransparency = 95; // % transparent

// This is the transparency that is visible when the fade effect is finished and the minimap is on

const TInt KDefaultViewingTransparency = 15; // % transparent

// Higher the KFadeEffectSpeed, the faster the fade effect. This tells directly 

// how much the percentage amount the transparency of the minimap is changed 

// every 0.03 second when the fade effect is shown.

// The suitable value depends on the performance of the hardware

// but if you consider a pure emulator, 5 is fine for the KFadeEffectSpeed

// but for example in Nokia E50 device something like 10 looks about the same.

const TInt KFadeEffectSpeed = 5;

// How often updated

const TInt KUpdateFreq = 30000;// 0.03 second

const TInt KDefaultWidthPercent = 67;

const TInt KDefaultHeightPercent = 78;

const TInt KDefaultOffsetX = 0;

const TInt KDefaultOffsetY = 3;

const CPageScaler::TPosition KDefaultPosition = CPageScaler::ETopRight;

const TInt KBorderWidthPermille = 20; // width of the border

const TInt KMaxBorderAlpha = 128; // how dark is the shadow around the minimap

// defines a box relative to minimap edges. if view center goes outside this box

// the view is recentered (50%==always center)

const TInt KHScrollAreaPercent = 33; // horizontal distance in percent

const TInt KVScrollAreaPercent = 50; // verical distance in percent

const TInt KHScrollAreaPercentWithTouch1 = 20; // horizontal distance in percent when to scrol

const TInt KVScrollAreaPercentWithTouch1 = 20; // verical distance in percent when to scrol

const TInt KHScrollAreaPercentWithTouch2 = 25; // horizontal distance in percent amount to scroll (scroll to the right only)

const TInt KVScrollAreaPercentWithTouch2 = 25; // verical distance in percent amount to scroll (scroll up only)

const TInt KUpdateDelayComplete = 45000000; // 45s

const TInt KUpdateDelayLoading = 7000000; // 7s

const TInt KUpdateDelayFullScreen = 4000000; // 4s

const TInt KUpdateCbDelayComplete = 100000; // 0.1s

const TInt KUpdateCbDelayLoading = 1000000; // 1s

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CMinimap:CMinimap

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMinimap::CMinimap(MPageScalerCallback& aCallback, TDisplayMode aMode, TBool aLowQuality)

    : iCallback(&aCallback),

      iZoomOutLevel(KDefaultZoomOutPercent),

      iTransparency(KDefaultTransparency),

      iDisplayMode(aMode),

      iWidthPercent(KDefaultWidthPercent),

      iHeightPercent(KDefaultHeightPercent),

      iMinimapUpdating( EFalse ),

      iLowQuality( aLowQuality )

    {

    }

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

// CMinimap::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMinimap::ConstructL()

    {

    iGenerator = CMinimapGenerator::NewL(*this);

    iUpdateCbTimer = CMinimapTimer::NewL(*this, &UpdateCbTimerCbL, CActive::EPriorityStandard - 1 );

    iUpdateTimer = CMinimapTimer::NewL(*this, &UpdateTimerCbL);

    iVisibilityTimer = CMinimapTimer::NewL(*this, &VisibilityTimerCbL);

    iFadeTimer = CMinimapTimer::NewL(*this, &UpdateTransparency);

    SetRelativePosition(KDefaultOffsetX,KDefaultOffsetY,KDefaultPosition);

    }

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

// CMinimap::NewL

// Two-phased constructor.

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

//

CMinimap* CMinimap::NewL(MPageScalerCallback& aCallback, TDisplayMode aMode, TBool aLowQuality)

    {

    CMinimap* self = new( ELeave ) CMinimap(aCallback, aMode, aLowQuality);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CMinimap::~CMinimap()

    {

    delete iGenerator;

    delete iUpdateCbTimer;

    delete iUpdateTimer;

    delete iVisibilityTimer;

    delete iFadeTimer;

    delete iMinimapBitmapGc;

    delete iMinimapBitmapDevice;

    delete iMinimapBitmap;

    delete iMinimapMaskBitmapGc;

    delete iMinimapMaskBitmapDevice;

    delete iMinimapMaskBitmap;

    iSprite.Close();

#if ENABLE_MINIMAP_COLORING

    delete iMinimapColoringBitmap;

    delete iMinimapColoringBitmapMask;

    delete iMinimapColoringBitmapMaskDevice;

    delete iMinimapColoringBitmapMaskGc;

#endif

    }

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

// CMinimap::SetRelativePosition

//

//

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

//

void CMinimap::SetRelativePosition(TInt aXDist, TInt aYDist, TPosition aPos)

    {

    //negative == relative to right/bottom edge

    iXDist = (aPos==ETopRight || aPos==EBottomRight)?-aXDist-1:aXDist;

    iYDist = (aPos==EBottomLeft || aPos==EBottomRight)?-aYDist-1:aYDist;

    }

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

// CMinimap::SetVisibleUntil

//

//

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

//

void CMinimap::SetVisibleUntil(TTimeIntervalMicroSeconds32 aUntil)

    {

    iVisibilityTimer->Start(aUntil);

    if (!iVisible)

        {

        SetVisible(ETrue);

        iCallback->ScaledPageChanged(Rect(), EFalse, EFalse);

        }

        iFadeDirection = ETrue;

        UpdateTransparency();

    }

void CMinimap::UpdateTransparency()

{

    if (iFullScreenMode) return;

	TInt delay = KUpdateFreq;

	iFadeTimer->Cancel();

	if (iFadeDirection) 

	{

		if (iTransparency > KDefaultViewingTransparency) 

		{

			iTransparency -= KFadeEffectSpeed;

			iFadeTimer->Start(delay);

			iCallback->ScaledPageChanged(Rect(), EFalse, EFalse);

		}

		else 

		{

			iTransparency = KDefaultViewingTransparency;

		}

	}

	else 

	{

		if (iTransparency < KDefaultTransparency) 

		{

			iTransparency += KFadeEffectSpeed;

			iFadeTimer->Start(delay);

			iCallback->ScaledPageChanged(Rect(), EFalse, EFalse);

		}

		else 

		{

			iTransparency = KDefaultTransparency;

			iVisible = EFalse;

			iCallback->ScaledPageChanged(Rect(), EFalse, EFalse);

		}

	}

    }

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

// CMinimap::Rect

//

//

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

//

TRect CMinimap::Rect() const

    {

    if (iFullScreenMode)

        {

        return iContainerRect;

        }

    if (!iMinimapBitmap)

        {

        return TRect();

        }

    TSize ressize(iMinimapBitmap->SizeInPixels());

    TPoint respoint;

    respoint.iX = iXDist<0?

        iContainerRect.Width()+iXDist-ressize.iWidth+1:iXDist;

    respoint.iY = iYDist<0?

        iContainerRect.Height()+iYDist-ressize.iHeight+1:iYDist;

    return TRect(respoint, ressize);

    }

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

// CMinimap::MinimapRect

//

// Rectangle containing the actual minimap (excluding borders)

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

//

TRect CMinimap::MinimapRect() const

    {

    TSize s;

    if (iFullScreenMode)

        {

        s = CalcSize();

        //center

        TPoint p((iContainerRect.Width()-s.iWidth)/2,(iContainerRect.Height()-s.iHeight)/2);

        return TRect(p,s);

        }

    else if (iMinimapBitmap)

        {

        s = iMinimapBitmap->SizeInPixels();

        }

    TInt bw = BorderWidth();

    if (s.iWidth<=bw*2 || s.iHeight<=bw*2)

        {

        return TRect();

        }

    // borders

    s -= TSize(bw*2,bw*2);

    return TRect(TPoint(bw,1),s);

    }

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

// CMinimap::IndicatorRect

//

// Calculate the main view indicator on minimap

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

//

TRect CMinimap::IndicatorRect() const

    {

    TRect vp(iCallback->DocumentViewport());

    TRect minimapVp(ViewportOnDocument());

    vp.Move(-minimapVp.iTl); //make vp relative to minimapVp

    TRect res = FromDocCoords(vp); //translate vp to mmap coords

    // borders

    res.Move(MinimapRect().iTl);

    // so that view area is within the indicator

    res.Grow(1,1);

    // ensure it is within the bounds

    TRect mr = MinimapRect();

    if (res.iTl.iX<mr.iTl.iX)

        {

        res.iTl.iX = mr.iTl.iX;

        }

    if (res.iTl.iY<mr.iTl.iY)

        {

        res.iTl.iY = mr.iTl.iY;

        }

    if (res.iBr.iX>mr.iBr.iX)

        {

        res.iBr.iX = mr.iBr.iX;

        }

    if (res.iBr.iY>mr.iBr.iY)

        {

        res.iBr.iY = mr.iBr.iY;

        }

    return res;

    }

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

// CMinimap::DocumentStarted

//

// Event from client: new document is being loaded

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

//

void CMinimap::DocumentStarted()

    {

    iDocumentComplete = EFalse;

    iViewportOnDocument = TRect();

    iUpdateTimer->Cancel();

    if ( iUpdateCbTimer->IsActive() )

        {

        UpdateNow();

        }

    iVisibilityTimer->Cancel();

    if ( iFadeDirection )

        {

        VisibilityTimerCbL();

        }

    iGenerator->Clear();

    TRAP_IGNORE(CheckAndCreateMinimapBitmapsL());

    iNeedsUpdate = EFalse;

    // keep bitmaps during loading to avoid constant realloc

    iGenerator->SetKeepsBitmaps(ETrue);

    iGenerator->VisitArea(iCallback->DocumentViewport());

    }

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

// CMinimap::DocumentChanged

//

// Event from client: changes in document

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

//

void CMinimap::DocumentChangedL()

    {

    TTimeIntervalMicroSeconds32 delay(

        iDocumentComplete?KUpdateCbDelayComplete:KUpdateCbDelayLoading);

    iUpdateCbTimer->Start( delay );

    }

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

// CMinimap::DocumentChangedCbL

//

// Event from client: changes in document

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

//

void CMinimap::DocumentChangedCbL()

    {

#ifdef __OOM__

    // disable updating when memory is low

    if( iGenerator->IsCollectingMemory() ) return;

#endif

    iGenerator->Invalidate();

    if( !iLowQuality )

        {

        CheckAndCreateMinimapBitmapsL();

        if (iUpdateTimer->IsActive())

            {

            // timer running, update when it completes

            iNeedsUpdate = ETrue;

            }

        else

            {

            if (iCallback->DocumentSize().iHeight>5)

                {

                iViewportOnDocument = CalcViewportOnDocument();

                iGenerator->UpdateL();

                iNeedsUpdate = EFalse;

                // don't do another update for..

                TTimeIntervalMicroSeconds32 delay(

                    iFullScreenMode?KUpdateDelayFullScreen:iDocumentComplete?KUpdateDelayComplete:KUpdateDelayLoading);

                iUpdateTimer->Start(delay);

                }

            }

        }

    else

        {

        iNeedsUpdate = ETrue;

        // don't start updating if the minimap is not visible

        if( iVisible )

            {

            if (iCallback->DocumentSize().iHeight>5)

                {

                iViewportOnDocument = CalcViewportOnDocument();

                iGenerator->UpdateL();

                iUpdateTimer->Start( 0 );

                }

            }

        }

    }

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

// CMinimap::DocumentViewportMoved

//

// Event from client: view position changed

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

//

void CMinimap::DocumentViewportMoved()

    {

    iViewportOnDocument = CalcViewportOnDocument();

#if ENABLE_MINIMAP_COLORING

    iGenerator->VisitArea(iCallback->DocumentViewport());

#endif

    iGenerator->ScrollL();

    if ( iVisible )

        {

        TRAP_IGNORE(iGenerator->UpdateL(ETrue));

        }

    else if( !iLowQuality )

        {

        iNeedsUpdate = ETrue;

        if (!iUpdateTimer->IsActive())

            {

            TTimeIntervalMicroSeconds32 delay(

                iDocumentComplete?KUpdateDelayComplete:KUpdateDelayLoading);

            iUpdateTimer->Start(delay);

            }

        }

    else

        iNeedsUpdate = ETrue;

    }

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

// CMinimap::SetMaxSize

//

// set maximum size for the minimap

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

//

void CMinimap::SetPercentSize(TInt aWidthPercent, TInt aHeightPercent)

    {

    iWidthPercent = aWidthPercent;

    iHeightPercent = aHeightPercent;

    TRAP_IGNORE(CheckAndCreateMinimapBitmapsL());

    }

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

// CMinimap::DocumentCompleted

//

// Event from client: document loading completed

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

//

void CMinimap::DocumentCompleted()

    {

    // this event is triggered by the minimap updating, not by 

    // the main document.

    if( iMinimapUpdating ) return;

    iNeedsUpdate = ETrue;

    iDocumentComplete = ETrue;

    if( iVisible || !iLowQuality )

        {

        iUpdateTimer->Start(0);

        }

    // we can delete the buffers now

    iGenerator->SetKeepsBitmaps(EFalse);

    }

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

// CMinimap::ViewportOnMinimap

//

// Area the minimap view covers in minimap coordinates

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

//

TRect CMinimap::ViewportOnMinimap() const

    {

    return FromDocCoords(iViewportOnDocument);

    }

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

// CMinimap::ViewportOnDocument

//

// Area the minimap view covers in document coordinates

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

//

TRect CMinimap::ViewportOnDocument() const

    {

    return iViewportOnDocument;

    }

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

// CMinimap::CalcSize

//

// Calculate minimap view size

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

//