/*

* Copyright (c) 1997-1999 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 <uiklaf/private/lafenv.h>

#include <lafpanic.h>

#include "LAFSTD.H"

#include <barsread.h>

#include <w32std.h>

#include <gulutil.h>

#include <coemain.h>

#include <eikpriv.rsg>

#include <aknborders.h>

#include "lafAknBorders.h"

#include <AknUtils.h>

#include <eikenv.h>

#include <bautils.h>

#include <aknnotewrappers.h>

#include <fontids.hrh>

#include <gulfont.h>

#include <uiklaf/private/lafmsg.h>

#include <AknFontIdLayoutFont.h>

#include <AknSystemFont.h>

#include <AknFontId.h>

#include <aknlayoutscalable_avkon.cdl.h> // Scalable layout API

#include <AknFontProvider.h>

const TUint EKeyDefault = EKeyDelete;	//setup as EKeyF11 (#defined in E32Keys.h)

const TInt KLafShadowHeight = 3;

const TInt KLafEnvDefaultLineSpacingInTwips = 158;

const TInt KDefaultFontIndex = 0;

_LIT(KRDSupport, "c:\\resource\\errrd" );

_LIT(KAknFirstStartedAppThreadName, "akncapserver");

const TUint8 KLogicalToAvkonColorMap[] =

	{

	0,		// EEikColorWindowBackground

	215,	// EEikColorWindowText

	0,		// EEikColorControlBackground

	215,	// EEikColorControlText

	0,		// EEikColorControlSurroundBackground

	215,	// EEikColorControlSurroundText

	244,	// EEikColorControlHighlightBackground

	215,	// EEikColorControlHighlightText

	0,		// EEikColorControlDimmedBackground

	215,	// EEikColorControlDimmedText

	244,	// EEikColorControlDimmedHighlightBackground

	215,	// EEikColorControlDimmedHighlightText

	0,		// EEikColorDialogBackground

	215,	// EEikColorDialogText

	0,		// EEikColorDialogTitle

	0,		// EEikColorDialogTitlePressed

	215,	// EEikColorDialogTitleText

	215,	// EEikColorDialogTitleTextPressed

	0,		// EEikColorMenubarBackground

	215,	// EEikColorMenubarText

	0,		// EEikColorMenubarTitleBackground

	215,	// EEikColorMenubarTitleText

	0,		// EEikColorMenuPaneBackground

	215,	// EEikColorMenuPaneText

	244,	// EEikColorMenuPaneHighlight

	215,	// EEikColorMenuPaneTextHighlight

	244,	// EEikColorMenuPaneDimmedHighlight

	215,	// EEikColorMenuPaneDimmedText

	244,	// EEikColorMenuPaneDimmedTextHighlight

	43,		// EEikColorButtonFaceClear

	0,		// EEikColorButtonFaceSet

	43,		// EEikColorButtonFaceSetPressed

	0,		// EEikColorButtonFaceClearPressed

	215,	// EEikColorButtonText

	215,	// EEikColorButtonTextPressed

	222,	// EEikColorButtonTextDimmed

	215,	// EEikColorMsgWinForeground

	244,	// EEikColorMsgWinBackground

	215,	// EEikColorScrollBarBorder

	0,		// EEikColorScrollBarShaft

	0,		// EEikColorScrollBarShaftDimmed

	222,	// EEikColorScrollBarShaftPressed

	0,		// EEikColorScrollBarNoShaftOrThumb

	215,	// EEikColorScrollButtonIcon

	215,	// EEikColorScrollButtonIconPressed

	222,	// EEikColorScrollButtonIconDimmed

	43,		// EEikColorScrollButtonThumbBackground

	0,		// EEikColorScrollButtonThumbBackgroundPressed

	216,	// EEikColorScrollThumbDimmed

	215,	// EEikColorScrollThumbEdge

	0,		// EEikColorToolbarBackground

	215,	// EEikColorToolbarText

	0,		// EEikColorStatusPaneBackground

	215,	// EEikColorStatusPaneText

	215,	// EEikColorLabelText

	215,	// EEikColorLabelTextEmphasis

	222,	// EEikColorLabelDimmedText

	222,	// EEikColorLabelHighlightPartialEmphasis

	215		// EEikColorLabelHighlightFullEmphasis

	};

/**

 * Creates an EText parser

 */

EXPORT_C MParser* LafEnv::CreateTextParserL(TInt /*aIndex*/)

	{ // static

	MParser* parser=NULL;

	return parser;

	}

// Local utility for loading resource file

LOCAL_C TInt LoadResFileL(CCoeEnv& aEnv, const TDesC& aFileName)

	{

	TFileName fileName(aFileName);

	BaflUtils::NearestLanguageFile(aEnv.FsSession(), fileName);

	return aEnv.AddResourceFileL(fileName);

	}

//This should only be called by MatchFont() in those cases where it is given a TLogicalFont

//without a Uid. In those cases this figures out what font to use based on the category

//and calls the relevant FontName() function. All switching by subvariant

//occurs in those FontName() functions (e.g. LatinPlain12() ) which then call

//MatchFont (so it's a call within a call), but this time

//with a Uid. 

LOCAL_C const CFont* GetRightFontFromCategory(const TLogicalFont::TFontCategory aCategory)

    {    

    switch (aCategory)

        {

        case TLogicalFont::EView:

            return CEikonEnv::Static()->NormalFont();

        case TLogicalFont::EButton:

            return CEikonEnv::Static()->DenseFont();

        case TLogicalFont::EAnnotation:

            return CEikonEnv::Static()->AnnotationFont();

        case TLogicalFont::ETitle:

            return CEikonEnv::Static()->TitleFont();

        default: //this should never happen as long as TLogicalFont always has

            // either Uid or a category and not further categories are defined

            // See the constructor for TLogicalFont

            __ASSERT_ALWAYS(0,Panic(ELafPanicFontUidUnknownOrMissing));	

            return NULL;//for compiler

        }        

    }

// Fetches the CFont* from the system font array.  THis will return NULL in the

// following cases: 

// - UID is not found

// - UID is found, but the CFont* there is NULL 

// (Panics where necessary will happen in MatchFont)

LOCAL_C const CFont* GetFontFromSystemArray( CArrayPtr<CAknSystemFont>& aSystemFonts, TInt aIdToBeMatched)

	{

	TInt count = aSystemFonts.Count();

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

		{

		const CAknSystemFont* font = aSystemFonts[i];

		if ((font) && (font->Uid().iUid == aIdToBeMatched))

			{

			return font->Font();

			}

		}

    // Font was not found

    CAknFontIdLayoutFont* layoutFont=NULL;

    CWsScreenDevice& screenDev=*(CEikonEnv::Static()->ScreenDevice());

    TRAPD(err, 

        {layoutFont = CAknFontIdLayoutFont::NewL( screenDev , aIdToBeMatched);

        } );

    if ( err == KErrNone )

    	{

    	CleanupStack::PushL( layoutFont );

    	// Create font and add to font array

    	TUid uid = TUid::Uid( aIdToBeMatched);

    	CAknSystemFont* systemFont = CAknSystemFont::NewL( uid, layoutFont ); 

    	CleanupStack::Pop( layoutFont );

		CleanupStack::PushL( systemFont );

    	aSystemFonts.AppendL( systemFont );

    	CleanupStack::Pop( systemFont );

    	return systemFont->Font();

    	}

    else if ( count > KDefaultFontIndex )

    	{

    	// return a default font if loading fails

		return aSystemFonts[KDefaultFontIndex]->Font();

    	}	

    else 

    	return NULL;

	}

LOCAL_C TBool IsFirstApp()

    {

    RThread thread;

    return ( thread.Name().CompareF( KAknFirstStartedAppThreadName) == 0 );

    }

/**

 * Returns the corner of the screen which the busy message should appear in

 * by default on the device.

 */

EXPORT_C TGulAlignment LafEnv::DefaultBusyMsgCorner()

	{// static

	return EHRightVBottom;

	}

/**

 * Populates aBitmaps with a set of system bitmaps.

 */

EXPORT_C void LafEnv::CreateSystemBitmapsL(CCoeEnv& /*aEnv*/, CArrayPtrFlat<CFbsBitmap>& /*aBitmaps*/)

	{ 

	// Empty implementation in Avkon

	}

LOCAL_C void AddStartupFontToSystemFontArrayL( CArrayPtr<CAknSystemFont>& aSystemFonts )

    {

    // Construct a font that is the same as the system startup font.  

    CWsScreenDevice& screenDev=*(CEikonEnv::Static()->ScreenDevice());

    TInt startupId = TAknFontId::FontIdForStartupNormalFont();

    CAknFontIdLayoutFont* layoutFont = CAknFontIdLayoutFont::NewL( screenDev , startupId);

    CleanupStack::PushL( layoutFont );

    // Create font and add to font array

    TUid uid = TUid::Uid( startupId); // Tag with the encoded font ID and not the logical

    CAknSystemFont* systemFont = CAknSystemFont::NewL( uid, layoutFont ); 

    CleanupStack::Pop( layoutFont );

    CleanupStack::PushL( systemFont );

    aSystemFonts.AppendL( systemFont );

    CleanupStack::Pop( systemFont );

    // Always should have 2 fonts at this point

    __ASSERT_ALWAYS( aSystemFonts.Count() == 2, Panic(ELafPanicFontCreationFailure));

    }

/**

 * Populate aFonts with a set of system fonts defined in eikpriv.rss

 * A minimum of one font must be created.

 */

EXPORT_C void LafEnv::CreateSystemFontsL(CCoeEnv& aEnv, CArrayPtr<CAknSystemFont>& aFonts)

	{

    // Ensure the system font array is set in Avkon extension

    CEikonEnv* env = static_cast<CEikonEnv*>(&aEnv);

    CAknEnv* aAknEnv = static_cast<CAknEnv*>(env->Extension());

    if (aAknEnv)

        {

        aAknEnv->iSystemFontArray = &aFonts;  // Friend class setting access to private member

        }

#ifdef AVKON_RDEBUG_INFO

    if (!aAknEnv)

        RDebug::Print(_L("LafEnv::CreateSystemFontsL - System Font Array pointer NOT set into AknEnv"));

#endif      

    TBool isFirstApp = IsFirstApp();

    // We will want NormalFont at index 0. Add it here by doing what CEikEnv will do

    TLogicalFont lf;

    lf.iFontId=TUid::Uid(KLafUidNormalFontVal);

    (void)LafEnv::MatchFont( aFonts, lf ); // Creates the future iNormalFont

    if ( isFirstApp )

        {

        // Create a 2nd system font in this app that will hold permanently open the dummy 

    	// font that all apps start up with (the initial iNormalFont)

    	AddStartupFontToSystemFontArrayL(aFonts);

    	// Also set the system defaults and aliases

    	// AknFontProvider::InitializeSystemL needs WriteDeviceData, and it only a co-incidence that the first app started 

    	// is AknCapServer with its high capabilities. These checks added for maintainability and debugability

    	RProcess process;

#ifdef AVKON_RDEBUG_INFO

    	if ( !process.HasCapability( ECapabilityWriteDeviceData) )

    	    {

    	    RDebug::Print(_L("LafEnv::CreateSystemFontsL - Not in high enough capability app to initialize fonts system-wide"));

    	    }

#endif 

        __ASSERT_ALWAYS( process.HasCapability( ECapabilityWriteDeviceData) , Panic(ELafPanicFontCreationFailure) );

        AknFontProvider::InitializeSystemL( static_cast<CEikonEnv&>(aEnv) );

        }   

    return; // nothing created from resource.

    }

LOCAL_C TInt MapSymbianLogicalFontUidToSeries60Id( TInt aUidToMap )

    {

    switch (aUidToMap)

        {

        case KLafUidNormalFontVal:

        return EAknLogicalFontPrimaryFont;

        case KLafUidAnnotationFontVal:

        return EAknLogicalFontPrimarySmallFont;

        case KLafUidDenseFontVal:

        return EAknLogicalFontSecondaryFont;

        case KLafUidTitleFontVal:

        return EAknLogicalFontTitleFont;

        case KLafUidSymbolFontVal:

        return EAknLogicalFontPrimarySmallFont;

        case KLafUidLegendFontVal:

        return EAknLogicalFontPrimarySmallFont;

        default:		

        return aUidToMap;

        }

    // no return required

    }

/**

 * Return the nearest match to aLogicalFont in aSystemFonts. 

 * If given an ordinary font Uid it returns the font.

 * If it is given one of the LogicalFont Uid's it will

 * effectively map this to a genuine font Uid and recursively call

 * MatchFont but this time with a proper Uid (will not do any further nested calls)

 * If it is given

 * a LogicalFont with no Uid but with a category, it uses the category to

 * figure out what Logical Font Uid to use, and then does a recursive call to MatchFont 

 * (i.e. itself) witha  Logical Font Uid as parameter, 

 * returning you to the situation just discussed above.

 * Thus at worst we get a call within a call within a call.

 * 

 * The return value must be non-NULL

 */

EXPORT_C const CFont* LafEnv::MatchFont( CArrayPtr<CAknSystemFont>& aSystemFonts,const TLogicalFont& aLogicalFont)

	{ 

	const CFont* font = NULL;

	// Need to check if aLogicalFont actually HAS a uid. If not, we  use its category 

	// (Note it is possible to have a TLogicalFont without a uid, but it is impossible 

	// to have one without a category.)

	TInt uidToMatch = aLogicalFont.iFontId.iUid;

	if (uidToMatch == KNullUid.iUid)

	//i.e. if there is no Uid 

		{	

			//this function call involves a call to matchFont itself, but this time WITH a Uid.

			//Should never end up in an infinite recursion

			//In fact should only ever be one call within another.

		font = GetRightFontFromCategory(aLogicalFont.iCategory);

		}

	else //this is the case that should happen nearly all the time

		{

        // Handle Symbian OS Logical Font Uids. Uid is translated to Series 60 logical font

        uidToMatch = MapSymbianLogicalFontUidToSeries60Id( uidToMatch );

        //if the fontid is not in the array or the Uid is there but without a CFont*,

		//it returns NULL

		font = GetFontFromSystemArray(aSystemFonts, uidToMatch);

        }

   	if ( !font )

        {

        // Create a Symbian font spec

        TFontSpec fontSpec;

    //	fontSpec.iTypeface.iName =  (*(productFontTable[foundIndex].iTypefaceName)).Left(KMaxTypefaceNameLength);

        fontSpec.iHeight = 12;

    	CWsScreenDevice& screenDev=*(CEikonEnv::Static()->ScreenDevice());

	    User::LeaveIfError(screenDev.GetNearestFontInPixels((CFont*&)font,fontSpec));

        }

    __ASSERT_ALWAYS( font, Panic(ELafPanicFontUidUnknownOrMissing) );

	return font;

	}

/**

 * Returns the nearest match to aBmpUid in aSystemBitmaps.

 */

EXPORT_C CFbsBitmap* LafEnv::MatchBitmap(const CArrayPtrFlat<CFbsBitmap>& aSystemBmps, TUid aBmpUid)

	{ // static

	CFbsBitmap* bitmap = NULL;

	const TInt32 uid = aBmpUid.iUid;

	if (uid >= KLafUidEikonTexturedVal && uid <= KLafUidEikonOptimVal)

		bitmap = aSystemBmps[uid-KLafUidEikonTexturedVal];

	__ASSERT_DEBUG(bitmap,Panic(ELafPanicBitmapIndexOutOfRange));

	return bitmap;

	}

/**

 * Draw's a logical border for aBorder, onto the graphics context aGc, in the rectangle aRect and using the

 * set of colors aBorderColors.

 */

EXPORT_C void LafEnv::DrawLogicalBorder(const TGulBorder& aBorder,CGraphicsContext& aGc, const TRect& aRect, const TGulBorder::TColors& aBorderColors)

	{ // static

	if (AknBorderId::EAknBorderNotePopup <= aBorder.Type() && aBorder.Type() < AknBorderId::EAknBorderMax)

		{

		LafAknBorders::DrawLogicalBorder(aBorder, aGc, aRect, aBorderColors);

		return;

		}

		TInt type;

	switch(aBorder.Type())

		{

	case TGulBorder::EWindow:

		type=TGulBorder::EThickDeepRaisedWithOutline;

		break;

	case TGulBorder::EFlatContainer:

		type=TGulBorder::ESingleBlack;

		break;

	case TGulBorder::ERaisedContainer:

		type=TGulBorder::EShallowRaised;

		break;

	case TGulBorder::ESunkenContainer:

		type=TGulBorder::EShallowSunken;

		break;

	case TGulBorder::EFlatControl:

		type=TGulBorder::ESingleGray;

		break;

	case TGulBorder::ERaisedControl:

		type=TGulBorder::EDeepRaisedWithOutline;

		break;

	case TGulBorder::ESunkenControl:

		type=TGulBorder::EDeepSunkenWithOutline;

		break;

	case TGulBorder::EFocusedRaisedControl:

		type=TGulBorder::EDeepRaisedWithOutline;

		break;

	case TGulBorder::EFocusedSunkenControl:

		type=TGulBorder::EDeepSunkenWithOutline;

		break;

	default:

		type=TGulBorder::ENone;

		break;

		}

	TGulBorder border(type);

	border.SetAdjacent(aBorder.Adjacent());

	border.Draw(aGc,aRect,aBorderColors);

	}

/**

 * Returns the margins of a logical border for aBorder.

 */

EXPORT_C TMargins LafEnv::LogicalBorderMargins(const TGulBorder& aBorder)

	{ // static

	if (AknBorderId::EAknBorderNotePopup <= aBorder.Type() && aBorder.Type() < AknBorderId::EAknBorderMax)

		{

		return LafAknBorders::LogicalBorderMargins(aBorder);

		}

	TInt type;

	switch(aBorder.Type())

		{

	case TGulBorder::EWindow:

		type=TGulBorder::EThickDeepRaisedWithOutline;

		break;

	case TGulBorder::EFlatContainer:

		type=TGulBorder::ESingleBlack;

		break;

	case TGulBorder::ERaisedContainer:

		type=TGulBorder::EShallowRaised;

		break;

	case TGulBorder::ESunkenContainer:

		type=TGulBorder::EShallowSunken;

		break;

	case TGulBorder::EFlatControl:

		type=TGulBorder::ESingleGray;

		break;

	case TGulBorder::ERaisedControl:

		type=TGulBorder::EDeepRaisedWithOutline;

		break;

	case TGulBorder::ESunkenControl:

		type=TGulBorder::EDeepSunkenWithOutline;

		break;

	case TGulBorder::EFocusedRaisedControl:

		type=TGulBorder::EDeepRaisedWithOutline;

		break;

	case TGulBorder::EFocusedSunkenControl:

		type=TGulBorder::EDeepSunkenWithOutline;

		break;

	default:

		type=TGulBorder::ENone;

		break;

		}

	TGulBorder border(type);

	border.SetAdjacent(aBorder.Adjacent());

	return border.Margins();

	}

/**

 * Returns the hardware key that corresponds to the default key.

 */

EXPORT_C TBool LafEnv::IsDefaultKey(TUint aCharCode)

	{// static

	return aCharCode==EKeyDefault;

	}

/**

 * Returns the default line spacing used to format text paragraphs.

 */

EXPORT_C TInt LafEnv::DefaultLineSpacingInTwips()

	{//static

	return KLafEnvDefaultLineSpacingInTwips;

	}

EXPORT_C TInt LafEnv::EditableControlStandardHeight(const MLafEnv& /*aLafEnv*/ )

	{

    // primary cursor extent is used as the standard editor height.  This is in agreement with	

    // a text query's editor field.

    TAknWindowLineLayout primaryLayout =