/*

* 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:

*

*/

// INCLUDE FILES

#include "AutolockContainer.h"

#include <eikenv.h>

#include <autolock.mbg>

#include <avkon.hrh>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <data_caging_path_literals.hrh>

#include "AutolockAppUiPS.h"

#include <Autolock.rsg>

#include "autolock.hrh"

#include <eikdef.h>

#include <coreapplicationuisdomainpskeys.h>

#include <AknsLayeredBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <AknBitmapAnimation.h>

#include    <AknsUtils.h>

#include	<AknUtils.h>

#include <e32property.h>

#include <PSVariables.h>   // Property values

#include <coreapplicationuisdomainpskeys.h>

#include <startupdomainpskeys.h>

#include <ctsydomainpskeys.h>

_LIT(BitmapName,"AutoLock.mbm");

// CONSTANTS

#ifdef RD_FULLSCREEN_WALLPAPER

enum TAutolockBgLayers

    {

    EAutolockBgLayerWallpaper      = 0,    

    EAutolockBgLayerBackground     = 1,

    EAutolockBgLayersN             = 2

    };

#else

enum TAutolockBgLayers

    {

    EAutolockBgLayerBackground     = 0,

    EAutolockBgLayerWallpaper      = 1,

    EAutolockBgLayersN             = 2

    };

#endif //RD_FULLSCREEN_WALLPAPER

        TInt aCallRect_x;

        TInt aCallRect_y;

        TInt aCallRect_width;

        TInt aCallRect_height;

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

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

// CAutolockContainer::ConstructL(const TRect& aRect)

// Symbian OS two phased constructor

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

//

void CAutolockContainer::ConstructL(const TRect& aRect)

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockContainer::ConstructL"));

    #endif

    CreateWindowL();

    HBufC* bitMapPath = HBufC::NewLC(KMaxPath);

    TPtr BitmapFile(bitMapPath->Des());

    BitmapFile.Append(_L("Z:"));

    BitmapFile.Append(KDC_APP_BITMAP_DIR);

    BitmapFile.Append(BitmapName);

    iEikBitmap = 0;

    iEikBitmapCall = 0;

    AknsUtils::CreateIconL( 

        AknsUtils::SkinInstance(), 

        KAknsIIDQgnGrafPhoneLocked,

        iBitmap,

        iMask,

        BitmapFile,

        EMbmAutolockQgn_graf_phone_locked, 

        EMbmAutolockQgn_graf_phone_locked_mask );

    AknsUtils::CreateIconL( 

        AknsUtils::SkinInstance(), 

        KAknsIIDQgnGrafPhoneLocked,

        iBitmapCall,

        iMaskCall,

        BitmapFile,

        EMbmAutolockQgn_indi_button_end_call, 

        EMbmAutolockQgn_indi_button_end_call_mask );

#ifdef RD_FULLSCREEN_WALLPAPER

    TSize screenSize = iCoeEnv->ScreenDevice()->SizeInPixels();

    TRect wallpaperRect( TPoint(0,0), screenSize );    

    iBgContext = CAknsLayeredBackgroundControlContext::NewL(

    KAknsIIDWallpaper, wallpaperRect, ETrue, EAutolockBgLayersN );

    SetRect(aRect);

#else    

    // Create background control context for skins. Use parent absolute mode,

    // as this is window owning control

    iBgContext = CAknsLayeredBackgroundControlContext::NewL(

        KAknsIIDQsnBgAreaMainIdle, aRect, ETrue, EAutolockBgLayersN );

    iBgContext->SetLayerImage( EAutolockBgLayerWallpaper, KAknsIIDWallpaper );

    iBgContext->SetLayerRect( EAutolockBgLayerWallpaper, aRect );

    SetRect(aRect);

#endif // RD_FULLSCREEN_WALLPAPER

    ActivateL();

    CleanupStack::PopAndDestroy(bitMapPath); //bitMapPath

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockContainer::ConstructL END"));

    #endif

    }

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

// CAutolockContainer::~CAutolockContainer()

// Destructor

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

//

CAutolockContainer::~CAutolockContainer()

    {

    delete iBgContext;

    delete iBitmap;

    delete iMask;

    delete iBitmapCall;

    delete iMaskCall;

	}

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

// CAutolockContainer::SizeChanged()

// Called by framework when the view size is changed

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

//

void CAutolockContainer::SizeChanged()

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockContainer::SizeChanged()"));

    #endif

    TRect mainPaneRect(Rect());

    TAknLayoutRect idleTradPane;

    idleTradPane.LayoutRect(mainPaneRect, AknLayoutScalable_Avkon::main_idle_trad_pane());

    TInt variety = 3;

    if (Layout_Meta_Data::IsLandscapeOrientation())

        {

        variety = 2;

        }

    TAknLayoutRect idlePaneG2;

    idlePaneG2.LayoutRect(idleTradPane.Rect(), AknLayoutScalable_Avkon::main_idle_pane_g2(variety));

    TInt callState = 0;

	  RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );

    if ( callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateUninitialized )

    	{

    AknIconUtils::SetSize( iBitmap, idlePaneG2.Rect().Size() );

    	}

    else

    	{

		  TSize lockSize = TSize(0.8 * idlePaneG2.Rect().Size().iWidth, 0.8 * idlePaneG2.Rect().Size().iHeight);

	    AknIconUtils::SetSize( iBitmap, lockSize );

    	}

		TSize callSize = TSize(60,60);

    AknIconUtils::SetSize( iBitmapCall, callSize );

#ifdef  RD_FULLSCREEN_WALLPAPER

    TSize screenSize = iCoeEnv->ScreenDevice()->SizeInPixels();

    TRect wallpaperRect( TPoint(0,0), screenSize );    

    iBgContext->SetLayerRect( EAutolockBgLayerBackground, Rect() ) ;

    iBgContext->SetLayerRect( EAutolockBgLayerWallpaper, wallpaperRect ) ;

    TPoint origo( 0, 0);

    iBgContext->SetParentPos(origo);

#else

    iBgContext->SetLayerRect( EAutolockBgLayerBackground, Rect() ) ;

    iBgContext->SetLayerRect( EAutolockBgLayerWallpaper, Rect() ) ;

    TPoint positionRelativeToScreen = PositionRelativeToScreen();

    //parent must be set when using parent absolute mode.

    iBgContext->SetParentPos(positionRelativeToScreen);

#endif //RD_FULLSCREEN_WALLPAPER

        RRegion autolockRegion;

#ifdef  RD_FULLSCREEN_WALLPAPER    	

    	autolockRegion.AddRect( wallpaperRect);

#else    	

    	autolockRegion.AddRect(Rect());

#endif //RD_FULLSCREEN_WALLPAPER   

        Window().SetShape(autolockRegion);

        autolockRegion.Close();

     #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockContainer::SizeChanged() END"));

    #endif

	 }

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

// CAutolockContainer::CountComponentControls() const

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

//

TInt CAutolockContainer::CountComponentControls() const

    {

    TInt controlCount = 0;

    return controlCount;

    }

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

// CAutolockContainer::ComponentControl(TInt aIndex) const

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

//

CCoeControl* CAutolockContainer::ComponentControl(TInt /*aIndex*/) const

    {

    return NULL;

	} 

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

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

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

//

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

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockContainer::Draw"));

    #endif

    if (AknLayoutUtils::PenEnabled() )

    	{

			TInt value = 0;

			RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, value);	    

			if(value <= EAutolockOff)

				{	// Avoid displaying the icon

				#if defined(_DEBUG)

				RDebug::Printf( "%s %s (%u) no Draw value=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, value );

				#endif

				return;

				}

			}

    CWindowGc& gc = SystemGc();

    gc.SetPenStyle(CGraphicsContext::ENullPen);

    gc.SetBrushColor(KRgbWhite); 

    gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

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

    // Draw "lock" icon centered to this control    

    // fist calculate the correct x coordinate based on this 

    // controls rect and bitmap width    

    TInt x = Rect().Width()/2 - iBitmap->SizeInPixels().iWidth /2;

    // and do same with y

    TInt y = Rect().Height()/2 - iBitmap->SizeInPixels().iHeight/2;

		TInt width =iBitmap->SizeInPixels().iWidth;

		TInt height =iBitmap->SizeInPixels().iHeight;

      TInt callState = 0;

  	  RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );

    if ( callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateUninitialized )

    	{

    	}

    else

    	{

    	y-=100;

    	}

    if (iBitmap && iMask)

        {

          // gc.BitBltMasked(TPoint(x,y),iBitmap,TRect(TPoint(0,0),iBitmap->SizeInPixels()), iMask, ETrue);

          gc.BitBltMasked(TPoint(x,y),iBitmap,TRect(TPoint(0,0),TPoint(width,height)), iMask, ETrue);

    	  if ( callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateUninitialized )

    	  	{

    	  }

    	  else

    	  	{

   	    	aCallRect_x=Rect().Width()/2 - iBitmapCall->SizeInPixels().iWidth/2;

		    	aCallRect_y=Rect().Height() * 0.75;

		    	aCallRect_width=iBitmapCall->SizeInPixels().iWidth;

		    	aCallRect_height=iBitmapCall->SizeInPixels().iHeight;

    	  	TSize cornerSize(20,20); 

    	  	TSize cornerEllipseSize(cornerSize.iHeight*2,cornerSize.iWidth*2);

    	  	TRect box(aCallRect_x-3*10	, aCallRect_y-3*10, aCallRect_x+aCallRect_width+3*10, aCallRect_y+aCallRect_height+3*10);

					TRect cornerRectTl(box.iTl,cornerEllipseSize);

					gc.SetBrushColor(KRgbRed); 

					gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

					gc.SetPenStyle(CGraphicsContext::EDottedPen);

					gc.DrawRoundRect(box,cornerSize);

        	gc.BitBltMasked(TPoint(aCallRect_x,aCallRect_y),iBitmapCall,TRect(TPoint(0,0),TPoint(aCallRect_width,aCallRect_height)), iMaskCall, ETrue);

        	}

        }

    else if (iBitmap && !iMask)

        {

        gc.BitBlt(TPoint(x,y),iBitmap);

    	  if ( callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateUninitialized )

    	  	{

    	  	}

    	  else

    	  	{

        	gc.BitBlt(TPoint(x,y+iBitmap->SizeInPixels().iHeight),iBitmapCall);

        	}

        }

    #if defined(_DEBUG)

    RDebug::Print(_L("(AUTOLOCK)CAutolockContainer::Draw END"));

    #endif

    }

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

// CAutolockContainer::HandleControlEventL(

//     CCoeControl* aControl,TCoeEvent aEventType)

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

//

void CAutolockContainer::HandleControlEventL(

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

    {

    }

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

// CAutolockContainer::MopSupplyObject

// 

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

//

TTypeUid::Ptr CAutolockContainer::MopSupplyObject( TTypeUid aId )

    {

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

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

void CAutolockContainer::GiveCoords( TRect& aRect )

    {

    	aRect.iBr.iX=aCallRect_x;

    	aRect.iBr.iY=aCallRect_y;

    	aRect.iTl.iX=aCallRect_width+2*3*10;

    	aRect.iTl.iY=aCallRect_height+2*3*10;

    }

// End of File