/*

* Copyright (c) 2002-2008 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:  Displays single startup screen. Animation not supported.

*

*/

// SYSTEM INCLUDES

#include <w32std.h>

#include <coedef.h>

#include <data_caging_path_literals.hrh>

#include <splashscreen.mbg>

#include <AknIconSrvClient.h>

#include <startupdomainpskeys.h>

// USER INCLUDES

#include "SplashScreen.h"

#include "SplashScreenDefines.h"

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

LOCAL_C void DoItL();

GLDEF_C TInt E32Main()

	{

    TRACES("E32Main(): Start");

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack

	TRAPD(error,DoItL()); // more initialization, then do Splash

	__ASSERT_ALWAYS(!error,User::Panic(KPanicMsg,error));

	delete cleanup; // destroy clean-up stack

	__UHEAP_MARKEND; // check no memory leak

    TRACES("E32Main(): End");

	return KErrNone;

	}

// 120 seconds (the splash should have been killed

// by the Starter before this runs out)

const TInt KSplashTimeout=(2* 60 * 1000000);

///////////////////////////////////////////////////////////////////////////////

////////////////////////// CWindow implementation /////////////////////////////

///////////////////////////////////////////////////////////////////////////////

CWindow::CWindow(CWsClient* aClient)

: iClient(aClient)

	{

    TRACES("CWindow::CWindow()");

	}

void CWindow::ConstructL (const TRect& aRect, CWindow* aParent)

	{

    TRACES("CWindow::ConstructL(): Start");

	// If a parent window was specified, use it; if not, use the window group

	// (aParent defaults to 0).

	RWindowTreeNode* parent= aParent ? (RWindowTreeNode*) &(aParent->Window()) : &(iClient->iGroup);

	iWindow=RWindow(iClient->iWs); // use app's session to window server

	User::LeaveIfError(iWindow.Construct(*parent,(TUint32)this));

    TRACES1("CWindow::ConstructL(): Start - window handle is: 0x%08x", this);

	iRect = aRect;

	iWindow.SetExtent(iRect.iTl, iRect.Size()); // set extent relative to group coords

	iWindow.Activate(); // window is now active

    TRACES("CWindow::ConstructL(): End");

	}

CWindow::~CWindow()

	{

    TRACES("CWindow::~CWindow(): Start");

	iWindow.Close(); // close our window

    TRACES("CWindow::~CWindow(): End");

	}

RWindow& CWindow::Window()

	{

    TRACES("CWindow::Window()");

	return iWindow;

	}

CWindowGc* CWindow::SystemGc()

	{

    TRACES("CWindow::SystemGc()");

	return iClient->iGc;

	}

///////////////////////////////////////////////////////////////////////////////

////////////////////////// CWsRedrawer implementation /////////////////////////

///////////////////////////////////////////////////////////////////////////////

CWsRedrawer::CWsRedrawer()

: CActive(CActive::EPriorityLow)

	{

    TRACES("CWsRedrawer::CWsRedrawer()");

	}

void CWsRedrawer::ConstructL(CWsClient* aClient)

	{

    TRACES("CWsRedrawer::ConstructL(): Start");

	iClient=aClient; // remember WsClient that owns us

	CActiveScheduler::Add(this); // add ourselves to the scheduler

	IssueRequest(); // issue request to draw

    TRACES("CWsRedrawer::ConstructL(): End");

	}

CWsRedrawer::~CWsRedrawer()

	{

    TRACES("CWsRedrawer::~CWsRedrawer(): Start");

	Cancel();

    TRACES("CWsRedrawer::~CWsRedrawer(): End");

	}

void CWsRedrawer::IssueRequest()

	{

    TRACES("CWsRedrawer::IssueRequest(): Start");

	iClient->iWs.RedrawReady(&iStatus);

	SetActive();

    TRACES("CWsRedrawer::IssueRequest(): End");

	}

void CWsRedrawer::DoCancel()

	{

    TRACES("CWsRedrawer::DoCancel(): Start");

	iClient->iWs.RedrawReadyCancel();

    TRACES("CWsRedrawer::DoCancel(): End");

	}

void CWsRedrawer::RunL()

	{

    TRACES("CWsRedrawer::RunL(): Start");

	// find out what must be done

	TWsRedrawEvent redrawEvent;

    iClient->iWs.GetRedraw(redrawEvent); // get event

	CWindow* window=(CWindow*)(redrawEvent.Handle()); // get window

	if (window)

		{

        TRACES1("CWsRedrawer::RunL(): window - 0x%08x", window);

		TRect rect=redrawEvent.Rect(); // and rectangle that needs redrawing

		// now do drawing

		iClient->iGc->Activate(window->Window());

		window->Window().BeginRedraw(rect);

		window->Draw(rect);

		window->Window().EndRedraw();

		iClient->iGc->Deactivate();

		}

	// maintain outstanding request

	IssueRequest();

    TRACES("CWsRedrawer::RunL(): End");

	}

CTimeout::CTimeout()

:   CTimer(0)

	{

    TRACES("CTimeout::CTimeout()");

	CActiveScheduler::Add(this);

	}

void CTimeout::ConstructL(CMainWindow* aWindow)

	{

    TRACES("CTimeout::ConstructL(): Start");

    CTimer::ConstructL();

	SetMainWindow( aWindow );

    TRACES("CTimeout::ConstructL(): End");

	}

void CTimeout::SetMainWindow( CMainWindow* aWindow )

    {

	iWindow = aWindow;

    }

void CTimeout::RunL()

	{

    TRACES("CTimeout::RunL(): Start");

	CActiveScheduler::Stop();

    if  ( iWindow )

        {

    	iWindow ->Client()->Group().SetOrdinalPosition(0,ECoeWinPriorityNeverAtFront);	// Background - so it's no more visible

        }

    TRACES("CTimeout::RunL(): End");

	}

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////// CWsClient implementation ////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

CWsClient::CWsClient()

: CActive(CActive::EPriorityStandard),

  iPSRemoveSplashState( ESplashRunning )

	{

    TRACES("CWsClient::CWsClient()");

	}

void CWsClient::ConstructL()

	{

    TRACES("CWsClient::ConstructL(): Start");

    RProperty::Define(KPSUidStartup,

                      KPSSplashShutdown,

                      RProperty::EInt,

                      KReadPolicy,

                      KWritePolicy );

    RProperty::Set( KPSUidStartup, KPSSplashShutdown, iPSRemoveSplashState );

	CActiveScheduler::Install(new (ELeave) CActiveScheduler);

	CActiveScheduler::Add(this);

    iProperty.Attach( KPSUidStartup, KPSSplashShutdown );

    iProperty.Subscribe( iStatus );

	// get a session going

	User::LeaveIfError(iWs.Connect());

	// construct screen device and graphics context

	iScreen=new (ELeave) CWsScreenDevice(iWs); // make device for this session

	User::LeaveIfError(iScreen->Construct( 0 )); // and complete its construction

	User::LeaveIfError(iScreen->CreateContext(iGc)); // create graphics context

    iLastScreenMode = iScreen->CurrentScreenMode();

    TRACES1("CWsClient::ConstructL() - iLastScreenMode: %d", iLastScreenMode);

	// construct our one and only window group

	iGroup=RWindowGroup(iWs);

	User::LeaveIfError(iGroup.Construct( (TInt) this,ETrue)); // meaningless handle; enable focus

    // Set our name for sending commands via key-events

    iGroup.SetName(KSplashScreenWindowGroup);

    TInt error = iGroup.EnableScreenChangeEvents();

    TRACES1("CWsClient::ConstructL() - enable screen change events: %d", error);

	// construct redrawer

	iRedrawer=new (ELeave) CWsRedrawer;

	iRedrawer->ConstructL(this);

    User::LeaveIfError( RAknIconSrvClient::Connect() );

	// construct main window

	ConstructMainWindowL();

    iWs.EventReady(&iStatus); // request an event

	SetActive(); // so we're now active

	// request first event and start scheduler

    TRACES("CWsClient::ConstructL(): About to start CActiveScheduler");

	CActiveScheduler::Start(); // start the active scheduler

    TRACES("CWsClient::CWsClient(): End");

	}

CWsClient::~CWsClient()

	{

    TRACES("CWsClient::~CWsClient(): Start");

    RAknIconSrvClient::Disconnect();

	// neutralize us as an active object

	Deque(); // cancels and removes from scheduler

	// get rid of scheduler and all attached objects

	delete CActiveScheduler::Current(); // delete the scheduler

	// get rid of everything we allocated

	delete iGc;

	delete iScreen;

	delete iRedrawer;

	// destroy window group

	iGroup.Close();

	// finish with window server

    Cancel();

    iProperty.Close();

	iWs.Close();

    TRACES("CWsClient::~CWsClient(): End");

	}

void CWsClient::Exit()

	{

    TRACES("CWsClient::Exit(): Start");

	CActiveScheduler::Stop();

    TRACES("CWsClient::Exit(): End");

	}

void CWsClient::IssueRequest()

	{

    TRACES("CWsClient::IssueRequest(): Start");

	iWs.EventReady(&iStatus); // request an event

	SetActive(); // so we're now active

    TRACES("CWsClient::IssueRequest(): End");

	}

void CWsClient::DoCancel()

	{

    TRACES("CWsClient::DoCancel(): Start");

	iWs.EventReadyCancel(); // cancel event request

    TRACES("CWsClient::DoCancel(): End");

	}

void CWsClient::ConstructMainWindowL()

	{

    TRACES("CWsClient::ConstructMainWindowL()");

	}

//////////////////////////////////////////////////////////////////////////////

//				Implementation for derived window classes

//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

//					 CMainWindow implementation							//

//////////////////////////////////////////////////////////////////////////////

/****************************************************************************\

|	Function:	Constructor/Destructor for CMainWindow

|				Doesn't do much, as most initialisation is done by the

|				CWindow base class.

|	Input:		aClient		Client application that owns the window

\****************************************************************************/

CMainWindow::CMainWindow (CWsClient* aClient)

: CWindow (aClient)

	{

    TRACES("CMainWindow::CMainWindow()");

	}

CMainWindow::~CMainWindow ()

	{

    TRACES("CMainWindow::~CMainWindow(): Start");

    delete iBitmap;

    TRACES("CMainWindow::~CMainWindow(): End");

	}

void CMainWindow::ConstructL (const TRect& aRect, CWindow* aParent)

	{

    TRACES("CMainWindow::ConstructL(): Start");

    TInt err( KErrNone );

	CWindow::ConstructL(aRect, aParent);

    TParse* fp = new(ELeave) TParse();

    fp->Set(KSplashBitmapName, &KDC_APP_BITMAP_DIR, NULL);

    TRACES1("CMainWindow::ConstructL(): Load Bitmap from %S", &fp->FullName());

    RFs fs;

    TInt thisTry = 0;

    while ( ( err = fs.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer )

        {

        User::After( KTimeBeforeRetryingServerConnection );

        }

    TFindFile findFile( fs );

    err = findFile.FindByPath( fp->FullName(), NULL );

    fs.Close();

    if ( !err )

        {

        TRACES("CMainWindow::ConstructL(): Image found");

#ifdef USE_SF_SPLASH_ENUM

        iBitmap = AknIconUtils::CreateIconL( fp->FullName(), EMbmSplashscreenSf_startup_screen );

#else

        iBitmap = AknIconUtils::CreateIconL( fp->FullName(), EMbmSplashscreenQgn_startup_screen );

#endif

        AknIconUtils::ExcludeFromCache(iBitmap);

        AknIconUtils::SetSize( iBitmap, iRect.Size(), EAspectRatioPreservedAndUnusedSpaceRemoved );

        }

    else

        {

        TRACES("CMainWindow::ConstructL(): Image not found");

        }

    delete fp;

    TRACES("CMainWindow::ConstructL(): End");

	}

/****************************************************************************\

|	Function:	CMainWindow::Draw

|	Purpose:	Redraws the contents of CMainWindow within a given

|				rectangle. As CMainWindow has no contents, it simply

|				clears the redraw area. A blank window could be used here

|				instead. The Clear() is needed because a redraw should

|				always draw to every pixel in the redraw rectangle.

|	Input:		aRect	Rectangle that needs redrawing

|	Output:		None

\****************************************************************************/

void CMainWindow::Draw(const TRect& aRect)

	{

    TRACES("CMainWindow::Draw(): Start");

	CWindowGc* gc=SystemGc(); // get a gc

	gc->SetClippingRect(aRect); // clip outside this rect

    TRACES2("CMainWindow::Draw(): Rect: X0=%d Y0=%d", aRect.iTl.iX, aRect.iTl.iY);

    TRACES2("CMainWindow::Draw(): Rect: X1=%d Y1=%d", aRect.iBr.iX, aRect.iBr.iY);

    TRACES1("CMainWindow::Draw(): iBitmap = %d", iBitmap);

	if (iBitmap)

		{

        TSize bmpSizeInPixels = iBitmap->SizeInPixels();

        //center image to the center of the screen

        TInt xDelta = ( aRect.Width() - bmpSizeInPixels.iWidth ) / 2;

        TInt yDelta = ( aRect.Height() - bmpSizeInPixels.iHeight ) / 2;

        TPoint pos = TPoint( xDelta , yDelta ); // displacement vector

        TRACES2("CMainWindow::Draw(): Image top left corner: X=%d Y=%d", pos.iX, pos.iY);

        gc->Clear();

		gc->BitBlt(pos, iBitmap);

		}

	else

		{

        TRACES("CMainWindow::Draw(): Image not available. Draw lines from corner to corner");

		TRect rect(Window().Position(), Window().Size());

		gc->DrawLine(rect.iTl, rect.iBr);

		gc->DrawLine(TPoint(rect.iTl.iX, rect.iBr.iY), TPoint(rect.iBr.iX, rect.iTl.iY));

		}

    TRACES("CMainWindow::Draw(): End");

	}

/****************************************************************************\

|	Function:	CMainWindow::HandlePointerEvent

|	Purpose:	Handles pointer events for CMainWindow.  Doesn't do

|				anything except get the co-ordinates where the pointer

|				event occurred.

|	Input:		aPointerEvent	The pointer event

|	Output:		None

\****************************************************************************/

void CMainWindow::HandlePointerEvent (TPointerEvent& /*aPointerEvent*/)

    {

    TRACES("CMainWindow::HandlePointerEvent(): Start");

//	TPoint point = aPointerEvent.iPosition;

//	(void)point;

    TRACES("CMainWindow::HandlePointerEvent(): End");

	}

//////////////////////////////////////////////////////////////////////////////

//					 CSplashWsClient implementation						//

//////////////////////////////////////////////////////////////////////////////

/****************************************************************************\

|	Function:	Constructor/Destructor for CSplashWsClient

|				Destructor deletes everything that was allocated by

|				ConstructMainWindowL()

\****************************************************************************/

CSplashWsClient::CSplashWsClient()

	{

    TRACES("CSplashWsClient::CSplashWsClient()");

	}

CSplashWsClient::~CSplashWsClient ()

	{

    TRACES("CSplashWsClient::~CSplashWsClient(): Start");

    if  ( iMainWindow )

        {

        TRACES("CSplashWsClient::~CSplashWsClient(): To background");

    	iMainWindow->Client()->Group().SetOrdinalPosition(-1,ECoeWinPriorityNormal);	// Back to the normal position

        iWs.Flush();

        }

	delete iMainWindow;

	delete iTimeout;

    TRACES("CSplashWsClient::~CSplashWsClient(): End");

	}

/****************************************************************************\

|	Function:	CSplashWsClient::ConstructMainWindowL()

|				Called by base class's ConstructL

|	Purpose:	Allocates and creates all the windows owned by this client

|				(See list of windows in CSplashWsCLient declaration).

\****************************************************************************/

void CSplashWsClient::ConstructMainWindowL()

	{

    TRACES("CSplashWsClient::ConstructMainWindowL(): Start");

	TSize windowSize=iScreen->SizeInPixels();

    CMainWindow* window = new (ELeave) CMainWindow(this);

    CleanupStack::PushL( window );

	window->ConstructL(TRect(TPoint(0,0), windowSize));

	window->Client()->Group().SetOrdinalPosition(0,ECoeWinPriorityAlwaysAtFront + 1);	// in front of the Status Bar

    delete iMainWindow;

    iMainWindow = window;

    CleanupStack::Pop( window );

    if  ( iTimeout == NULL )

        {

	    iTimeout = new (ELeave) CTimeout;

	    iTimeout->ConstructL(iMainWindow);

	    iTimeout->After(KSplashTimeout);

        }

    else

        {

        iTimeout->SetMainWindow( window );

        }

    TRACES("CSplashWsClient::ConstructMainWindowL(): End");

	}

/****************************************************************************\

|	Function:	CSplashWsClient::RunL()

|				Called by active scheduler when an even occurs

|	Purpose:	Processes events according to their type

|				For key events: calls HandleKeyEventL() (global to client)

|				For pointer event: calls HandlePointerEvent() for window

|                                  event occurred in.

\****************************************************************************/

void CSplashWsClient::RunL()

	{

    TRACES("CSplashWsClient::RunL(): Start");

    TInt state;

    RProperty::Get( KPSUidStartup, KPSSplashShutdown, state );

    TRACES1("CSplashWsClient::RunL(): KPSSplashShutdown state = %d", state);

    if ( state != iPSRemoveSplashState )

        {

        TRACES("CSplashWsClient::RunL(): KPSSplashShutdown state has changed -> PS event");

        if ( state == ESplashShutdown )

            {

            TRACES("CSplashWsClient::RunL(): Exit requested");

            Exit();

            }