/*

* Copyright (c) 2006 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:  CCSXHLegacyTopicContainer class definition

*

*/

#include "CSXHLegacyTOC2.h"

#include "CSXHLegacyTopicContainer.h"

#include "CSXHDocument.h"

#include "CSXHAppUi.h"

#include <eikrted.h>

#include <txtrich.h>

#include <aknkeys.h>

#include <AknUtils.h>

#include <barsread.h>

#include <applayout.cdl.h>    //Dynamic layout functions

#include <AknsDrawUtils.h> 

#include <AknsBasicBackgroundControlContext.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknappui.h>

#include <txtfrmat.h> 

#include <cshelp.rsg>

CCSXHLegacyTopicContainer* CCSXHLegacyTopicContainer::NewL(const TRect& 

aRect,CCSXHDocument &aDocument,CCSXHLegacyTOC2 *aTopic)

    {

    CCSXHLegacyTopicContainer* self = CCSXHLegacyTopicContainer::NewLC(aRect,aDocument,aTopic);

    CleanupStack::Pop(self);

    return self;

    }

CCSXHLegacyTopicContainer* CCSXHLegacyTopicContainer::NewLC(const TRect& 

aRect,CCSXHDocument &aDocument,CCSXHLegacyTOC2 *aTopic)

    {

    CCSXHLegacyTopicContainer* self = new (ELeave) CCSXHLegacyTopicContainer(aDocument,aTopic);

    CleanupStack::PushL(self);

    self->ConstructL(aRect);

    return self;

    }

CCSXHLegacyTopicContainer::CCSXHLegacyTopicContainer(CCSXHDocument 

&aDocument,CCSXHLegacyTOC2 *aTopic):iDocument(aDocument),iTopic(aTopic)

    {

    }

void CCSXHLegacyTopicContainer::ConstructL(const TRect& aRect/*, CRichText* aText*/)

    {

    CreateWindowL();

    TRect rect(0,0,0,0);

    // Temporary rect is passed. Correct rect is set in SizeChanged.

    iSkinContext = CAknsBasicBackgroundControlContext::NewL(

       KAknsIIDQsnBgAreaMain , rect, EFalse);

    iText = STATIC_CAST(CRichText*,iTopic->GetTopicContentL());

    GetTextFormat();

    iEdwin = new(ELeave) CEikEdwin();

    TInt flags(CEikEdwin::EKeepDocument |

               CEikEdwin::EUserSuppliedText |

               CEikEdwin::ENoAutoSelection |

               CEikEdwin::EAvkonDisableCursor |

               CEikEdwin::EReadOnly |

               CEikEdwin::EDisplayOnly);

    if ( iText == NULL )

        {

        flags = flags & ~CEikEdwin::EUserSuppliedText;

        }

    iEdwin->SetContainerWindowL(*this);

    iEdwin->ConstructL(flags);

    iEdwin->CreatePreAllocatedScrollBarFrameL()->SetScrollBarVisibilityL(

                                                 CEikScrollBarFrame::EOff,

                                                 CEikScrollBarFrame::EAuto);

    SetTextL(iText);

    if( iText != NULL )

        {

        FormatRichTextL(*iText);

        }

    SetRect(aRect);

    ActivateL();

    }

CCSXHLegacyTopicContainer::~CCSXHLegacyTopicContainer()

    {

    delete iEdwin;

    delete iSkinContext;

    }

void CCSXHLegacyTopicContainer::RefreshL(CCSXHLegacyTOC2 *aTopic)

    {

    iTopic = aTopic;

    iText = STATIC_CAST(CRichText*,iTopic->GetTopicContentL());

    SetTextL(iText);

    if( iText != NULL )

        {

        FormatRichTextL(*iText);

        }

    SizeChanged();

    }

void CCSXHLegacyTopicContainer::SetTextL(CRichText* aText)

    {

    if( aText == NULL )

        {

        HBufC* errorMessage = iCoeEnv->AllocReadResourceLC( R_TYPE_NO_HELP_TOPICS );

        iEdwin->SetTextL( errorMessage );

        CleanupStack::PopAndDestroy( errorMessage ); 

        }

    else

        {

        iEdwin->SetDocumentContentL(*aText, CEikEdwin::EUseText);

        iEdwin->SetCursorPosL(0, EFalse);

        }    

    }

void CCSXHLegacyTopicContainer::FocusChanged(TDrawNow aDrawNow)

    {

    if (iEdwin)

        {

        iEdwin->SetFocus(IsFocused(), aDrawNow);

        }

    }

void CCSXHLegacyTopicContainer::GetTextFormat()

    {

    TAknMultiLineTextLayout layoutToUse;

    if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )

        {

        TAknTextLineLayout layoutnew1 = AknLayoutScalable_Apps::help_list_pane_t1(0).LayoutLine();

        TAknLayoutScalableParameterLimits limits1 = 

            AknLayoutScalable_Apps::help_list_pane_t1_ParamLimits();

        TInt numberoflines = limits1.LastRow() + 1;

        layoutnew1.iNumberOfLinesShown = numberoflines ;

        layoutToUse.iC = layoutnew1.iC;

        layoutToUse.il = layoutnew1.il;

        layoutToUse.ir = layoutnew1.ir;

        layoutToUse.iB = layoutnew1.iB;

        layoutToUse.iW = layoutnew1.iW;

        layoutToUse.iJ = layoutnew1.iJ;

        layoutToUse.iFont = layoutnew1.iFont;

        layoutToUse.iBaselineSkip = layoutnew1.iBaselineSkip;

        layoutToUse.iNumberOfLinesShown = layoutnew1.iNumberOfLinesShown;

        }

    else

        {

        layoutToUse = AppLayout::Multiline_Help_texts_Line_1(0);

        }

    const CFont* font = AknLayoutUtils::FontFromId(layoutToUse.FontId() /*iFont*/, NULL);

    iCharFormat.iFontSpec = font->FontSpecInTwips();

    iCharFormatMask.SetAttrib(EAttFontTypeface);

    iCharFormatMask.SetAttrib(EAttFontHeight);

    TRgb color;

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TInt error = AknsUtils::GetCachedColor(skin, color, KAknsIIDQsnTextColors, 

    													EAknsCIQsnTextColorsCG6 );

    if(error==KErrNone)

        iCharFormat.iFontPresentation.iTextColor = color;

    iCharFormatMask.SetAttrib(EAttColor);

    iCharFormatMask.SetAttrib(EAttFontPosture);    

 }

void CCSXHLegacyTopicContainer::FormatRichTextL( CRichText& aText )

    {

    TInt length = aText.DocumentLength();

    length++;

    // Apply the general formatting rules...

    aText.ApplyCharFormatL( iCharFormat, iCharFormatMask, 0, length );

    TParaFormatMask paraFormatMask;

	paraFormatMask.SetAttrib( EAttBullet );

	CParaFormat *paraFormat  = new ( ELeave ) CParaFormat;

	CleanupStack::PushL(paraFormat);	

	TInt paraCount = aText.ParagraphCount();

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

		{

		TInt paraLength;

		TInt paraStart = aText.CharPosOfParagraph(paraLength,i);

		aText.GetParagraphFormatL(paraFormat,paraStart);

		if(paraFormat->iBullet)

			{

			TBullet* bullet = new ( ELeave ) TBullet;

			CleanupStack::PushL(bullet);

			bullet->iColor = iCharFormat.iFontPresentation.iTextColor;

			bullet->iHeightInTwips = iCharFormat.iFontSpec.iHeight;

			CParaFormat* paraFormatNew = new ( ELeave ) CParaFormat;			

			paraFormatNew->iBullet = bullet; // ownership xfer

			CleanupStack::Pop();

			CleanupStack::PushL(paraFormatNew);

			aText.ApplyParaFormatL( paraFormatNew, paraFormatMask, paraStart, paraLength - 1);

			CleanupStack::PopAndDestroy(paraFormatNew);

			}

		}

	CleanupStack::PopAndDestroy(paraFormat);

    }

void CCSXHLegacyTopicContainer::SizeChanged()

    {

	if(iSkinContext)

        	iSkinContext->SetRect(Rect());

    if(iEdwin)

    	{

    	TRect clientrect = Rect();

    	if(AknLayoutUtils::LayoutMirrored())

			{

			clientrect.iTl.iX = clientrect.iTl.iX + (iEdwin->ScrollBarFrame()

    				->ScrollBarBreadth(CEikScrollBar::EVertical))* 1.1;    		

			}

		else

			{

    		TInt RectWidth =  clientrect.Width() - (iEdwin->ScrollBarFrame()

    				->ScrollBarBreadth(CEikScrollBar::EVertical))* 1.1;      

    		clientrect.SetWidth(RectWidth);

			}

       	iEdwin->SetRect(clientrect);

       	TRAP_IGNORE(iEdwin->ForceScrollBarUpdateL());

    	}    

    }

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

// CCsHelpTopicContainer::OfferKeyEventL(...)

// Processing a key event

//  

// (other items were commented in a header).

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

TKeyResponse CCSXHLegacyTopicContainer::OfferKeyEventL(

                                      const TKeyEvent& aKeyEvent,

                                      TEventCode aType)

    {

    TKeyResponse result(EKeyWasConsumed);

    switch (aKeyEvent.iCode)

        {            

        case EKeyUpArrow:

            iEdwin->MoveDisplayL(TCursorPosition::EFLineUp);

            iEdwin->UpdateScrollBarsL();

            break;

        case EKeyDownArrow:

            iEdwin->MoveDisplayL(TCursorPosition::EFLineDown);

            iEdwin->UpdateScrollBarsL();

            break;

        default:

            result = iEdwin->OfferKeyEventL(aKeyEvent, aType);

        }

    return result;

    }

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

// CCsHelpTopicContainer::CountComponentControls() const

//

//  

// (other items were commented in a header).

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

//

TInt CCSXHLegacyTopicContainer::CountComponentControls() const

    {

    return 1; // return nbr of controls inside this container

    }

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

// CCsHelpTopicContainer::ComponentControl(TInt aIndex) const

//

// (other items were commented in a header).

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

//

CCoeControl* CCSXHLegacyTopicContainer::ComponentControl(TInt aIndex) const

    {

    switch ( aIndex )

        {

        case 0:

            return iEdwin;

        default:

            return NULL;

        }

    }

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

// CCsHelpTopicContainer::Draw(..)

//

// (other items were commented in a header).

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

//

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

    {

    CWindowGc& gc = SystemGc();

    gc.Clear(aRect);

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if (iSkinContext)

        {//Draw the skin background

        AknsDrawUtils::Background(

            skin, iSkinContext, this, gc, aRect);

        }

    }

void CCSXHLegacyTopicContainer::HandleResourceChange(TInt aType)

    {

     CCSXHAppUi::GetInstance()->PropagateResourceChange(aType);                

    }

void CCSXHLegacyTopicContainer::HandleResourceChangeImpl(TInt aType)

    {

    if(aType == KEikDynamicLayoutVariantSwitch)

        {

        iEdwin->HandleResourceChange(aType);

        TRect mainRect; 

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

        SetRect(mainRect);        

        }

    else

        {

        CCoeControl::HandleResourceChange(aType);

        }

    }

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

// CCsHelpTopicContainer::MopSupplyObject()

// Pass skin information if need.

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

TTypeUid::Ptr CCSXHLegacyTopicContainer::MopSupplyObject(TTypeUid aId)

    {

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

        {

        return MAknsControlContext::SupplyMopObject(aId, iSkinContext);

        }

    return CCoeControl::MopSupplyObject(aId);

    }

// End of File