/*

* Copyright (c) 2002-2004 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:  device context

*

*/

// INCLUDE FILES

#include <e32def.h>  // First to avoid NULL redefine warning (no #ifndef NULL).

#include "nw_object_dynamici.h"

#include "GDIFont.h"

#include "nw_gdi_utils.h"

#include "nw_text_ucs2.h"

#include <nwx_string.h>

#include <nwx_settings.h>

#include "nwx_logger.h"

#include "nwx_http_defs.h"

#include <AknUtils.h>

#include <gdi.h>

#include <w32std.h>

#include <eikenv.h>

#include <barsread.h>

#include <gulutil.h>

#include <bautils.h>

#include <webkit.rsg>

#include <biditext.h>

#include "BrsrStatusCodes.h"

#include <AknFontAccess.h>

#include <bldvariant.hrh>

#include <data_caging_path_literals.hrh>

#include "MemoryManager.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

/*

 The Thai language is unique in that it has certain characters that combine

 into a single entity that will be referred to as a Thai script "cell" or just

 "cell" for short.  Furthermore, the language uses white space very sparingly,

 frequently not having any space at all between individual words. These unique

 features create additional complexity when truncating or word-wrapping Thai

 text.

 Truncation should not occur in the middle of a "cell" if possible. The

 exception is if all that remains to be displayed is a single cell but

 there isn't space for the entire cell.

 As for word-wrapping, in optimal case, Thai text ought to be broken into lines

 at word boundaries. However, because white space is seldom used, word

 boundaries cannot be found unless a dictionary or a heavy statistical/

 morphological analysis is run on the text. Therefore, a less perfect approach

 is used.

 Line breaking is done according to Thai script "cells", which can be

 thought of as the smallest indivisible units of the script.

 The cells consist of combinations of characters from the following classes

 of characters, which are divided into two types -- spacing and combining:

   CONS  Consonant       (spacing)

   AD    Above Diacritic (combining)

   AV    Above Vowel     (combining)

   BD    Below Diacritic (combining)

   BV    Below Vowel     (combining)

   FV    Following Vowel (spacing)

   LV    Leading Vowel   (spacing)

   NON   Not a Thai letter, i.e. is a number, currency, etc (spacing)

   TONE  Tone mark       (combining)

 Graphically, the "cells" are built around a consonant, which functions as a

 base for a stack of combining elements, optionally preceded and/or followed

 by spacing vowels. The graph below illustrates how the bits and pieces of a

 cell are placed around the consonant:

             [TONE]

          [AV/AD/TONE]

_______[LV]__[CONS]__[FV]________  (baseline)

            [BV/BD]

 In the encoded text, you can anticipate sequences like:

 ... [LV] [CONS] [AV/BV/AD/BD] [TONE] [FV] ...

 If such is a prototype of a Thai script "cell", lines can be split without

 interfering with the most crucial structures of the script

   * between subsequent [FV] and [LV]

   * between subsequent [CONS] and [LV]

   * between subsequent [AV/BV/AD/BD] and [LV]

   * between subsequent [TONE] and [LV]

   * between subsequent [CONS] and [CONS]

   * between subsequent [AV/BV/AD/BD] and [CONS]

   * between subsequent [TONE] and [CONS]

   * between subsequent [FV] and [CONS]

 This can be reduced to the following three rules:

   1. Splits can occur at whitespace.

   2. Splits can occur immediately preceding any LV.

   3. Splits can occur immediately preceding any CONS that is not

     immediately preceded by an LV.

 Unfortunately, this approach does not guarantee individual words, or even

 individual syllables, from being broken across lines. All that can be said is

 that the outer structure of the script is preserved - combining characters as

 well as the leading/following vowels stick with the base character.

*/

// Thai unicode char range: 0x0E00 - 0x0E7F. Note, only the first 0x60

// characters are used.

#define THAI_CHAR_BASE 0x0E00

// Charcter classes and types.

#define THAI_CHAR_COMBINING_TYPE_FLAG 0x80

#define THAI_CHAR_SPACING_TYPE_FLAG   0x40

#define THAI_CHAR_CONS (1 | THAI_CHAR_SPACING_TYPE_FLAG)

#define THAI_CHAR_AD   (2 | THAI_CHAR_COMBINING_TYPE_FLAG)

#define THAI_CHAR_AV   (3 | THAI_CHAR_COMBINING_TYPE_FLAG)

#define THAI_CHAR_BD   (4 | THAI_CHAR_COMBINING_TYPE_FLAG)

#define THAI_CHAR_BV   (5 | THAI_CHAR_COMBINING_TYPE_FLAG)

#define THAI_CHAR_FV   (6 | THAI_CHAR_SPACING_TYPE_FLAG)

#define THAI_CHAR_LV   (7 | THAI_CHAR_SPACING_TYPE_FLAG)

#define THAI_CHAR_NON  (8 | THAI_CHAR_SPACING_TYPE_FLAG)

#define THAI_CHAR_TONE (9 | THAI_CHAR_COMBINING_TYPE_FLAG)

// Map that defines the class and type for each Thai character.

// Character range

const TUint8 ThaiCharMap[0x60] =

    {

    // 0x0E00

    THAI_CHAR_NON,

    // 0x0E01 - 0x0E23

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    // 0x0E24

    THAI_CHAR_FV,

    // 0x0E25

    THAI_CHAR_CONS,

    // 0x0E26

    THAI_CHAR_FV,

    // 0x0E27 - 0x0E2E

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    THAI_CHAR_CONS, THAI_CHAR_CONS, THAI_CHAR_CONS,

    // 0x0E2F

    THAI_CHAR_NON,

    // 0x0E30

    THAI_CHAR_FV,

    // 0x0E31

    THAI_CHAR_AV,

    // 0x0E32 - 0x0E33

    THAI_CHAR_FV, THAI_CHAR_FV,

    // 0x0E34 - 0x0E37

    THAI_CHAR_AV, THAI_CHAR_AV, THAI_CHAR_AV, THAI_CHAR_AV,

    // 0x0E38 - 0x0E39

    THAI_CHAR_BV, THAI_CHAR_BV,

    // 0x0E3A

    THAI_CHAR_BD,

    // 0x0E3B - 0x0E3F

    THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON,

    // 0x0E40 - 0x0E44

    THAI_CHAR_LV, THAI_CHAR_LV, THAI_CHAR_LV, THAI_CHAR_LV, THAI_CHAR_LV,

    // 0x0E45

    THAI_CHAR_FV,

    // 0x0E46

    THAI_CHAR_NON,

    // 0x0E47

    THAI_CHAR_AD,

    // 0x0E48 - 0x0E4B

    THAI_CHAR_TONE, THAI_CHAR_TONE, THAI_CHAR_TONE, THAI_CHAR_TONE,

    // 0x0E4C - 0x0E4E

    THAI_CHAR_AD, THAI_CHAR_AD, THAI_CHAR_AD,

    // 0x0E4F - 0x0E5F

    THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON,

    THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON,

    THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON, THAI_CHAR_NON,

    THAI_CHAR_NON, THAI_CHAR_NON

    };

// MACROS

#define IS_THAI_CHAR(c) ((c >= 0x0E00) && (c <= 0x0E60))

//#define IS_THAI_LEADING_VOWEL(c) ((c >= 0x0E40) && (c <= 0x0E44))

#define IS_THAI_LEADING_VOWEL(c) (ThaiCharMap[c - THAI_CHAR_BASE] == THAI_CHAR_LV)

//#define IS_THAI_CONSONANT(c) ((c >= 0x0E01) && (c <= 0x0E2E) && (c != 0x0E24) && (c != 0x0E26))

#define IS_THAI_CONSONANT(c) (ThaiCharMap[c - THAI_CHAR_BASE] == THAI_CHAR_CONS)

//#define IS_THAI_FOLLOWING_VOWEL(c) ((c == 0x0E24) || (c == 0x0E26) || (c == 0x0E30) || (c == 0x0E32) || (c == 0x0E33) || (c == 0x0E45))

#define IS_THAI_FOLLOWING_VOWEL(c) (ThaiCharMap[c - THAI_CHAR_BASE] == THAI_CHAR_FV)

#define IS_THAI_COMBINING(c) (ThaiCharMap[c - THAI_CHAR_BASE] & THAI_CHAR_COMBINING_TYPE_FLAG)

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CGDIDeviceContext::CGDIDeviceContext

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

// might leave.

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

//

CGDIDeviceContext::CGDIDeviceContext()

  {

  }

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

// CGDIDeviceContext::CGDIDeviceContext

// Symbian 2nd phase constructor can leave.

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

//

TBrowserStatusCode

CGDIDeviceContext::ConstructL (void* aGraphicsContext,

                               CView* aOocEpoc32View)

  {

  // initialize the member variables

  iGraphicsContext = aGraphicsContext;

  if( !iGraphicsContext )

    {

    return KBrsrFailure;

    }

  iOocEpoc32View = aOocEpoc32View;

  if( !iOocEpoc32View )

    {

    return KBrsrFailure;

    }

  iVariantFlag = AknLayoutUtils::Variant();

  _LIT( KResourceFile, "\\resource\\Webkit.rsc");

  _LIT( KResourceFileZ, "Z:Webkit.rsc");  

  TFileName resourceFileName; 

  TParse parse;   

  Dll::FileName (resourceFileName);          

  parse.Set(KResourceFile, &resourceFileName, NULL);

  resourceFileName = parse.FullName();

  CCoeEnv* coeEnv=CCoeEnv::Static();

  BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceFileName);

  if ( !BaflUtils::FileExists( coeEnv->FsSession(), resourceFileName ) )          

      {

      // Use resource file on the Z drive instead 

      parse.Set( KResourceFileZ, &KDC_RESOURCE_FILES_DIR, NULL );

      resourceFileName = parse.FullName(); 

      BaflUtils::NearestLanguageFile( coeEnv->FsSession(),resourceFileName );         	

      }

  iResourceFileOffset = coeEnv->AddResourceFileL(resourceFileName);

  // Get the array of available fonts on the phone

  CEikonEnv* eikEnv = CEikonEnv::Static();

  iWsScreenDev = eikEnv->ScreenDevice();

  // Create the font cache

  iFontCache = new (ELeave) CFontCache(30);  // 30 items in cache

  // Find out which language we support

  if ( FeatureManager::FeatureSupported(KFeatureIdAvkonELaf) )

      {

      iSupportedLanguage = EElafLanguage;

      }

  else if ( FeatureManager::FeatureSupported(KFeatureIdAvkonApac) )

    {

    if ( FeatureManager::FeatureSupported(KFeatureIdThai) )

        {

        iSupportedLanguage = EThaiLanguage;

        }

    else if ( FeatureManager::FeatureSupported(KFeatureIdJapanese) )

        {

        iSupportedLanguage = EJapaneseLanguage;

        }

    else if ( FeatureManager::FeatureSupported(KFeatureIdChineseTaiwanHkFonts) )

        {

        iSupportedLanguage = EChinaHKTWLanguage;

        }

    else  if ( FeatureManager::FeatureSupported(KFeatureIdChinesePrcFonts) )

        {

        iSupportedLanguage = EChinesePRCLanguage;

        }

    }

  iFillPattern=NW_GDI_Pattern_Solid;

  iLinePattern=NW_GDI_Pattern_Solid;

  iPaintMode=(NW_GDI_PaintMode_e)CGraphicsContext::EDrawModePEN;

  iLineWidth=1;

  iFontSizeLevel = EGDIDeviceContextFontSizeLevelNormal;

  // successful completion

  return KBrsrSuccess;

  }

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

// CGDIDeviceContext::NewL

// Two-phased constructor.

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

//

CGDIDeviceContext* CGDIDeviceContext::NewL (void* aGraphicsContext,

                                            CView* aOocEpoc32View)

  {

  CGDIDeviceContext* self = new( ELeave ) CGDIDeviceContext();

  CleanupStack::PushL( self );

  self->ConstructL(aGraphicsContext, aOocEpoc32View);

  CleanupStack::Pop();

  return self;

  }

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

// Destructor

//

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

//

CGDIDeviceContext::~CGDIDeviceContext()

    {

    CFont* font = NULL;

    CBitmapContext* gc = Epoc32GraphicsContext();

    while ((font = iFontCache->RemoveFirstEntry()) != NULL)

        {

        gc->DiscardFont();

        iWsScreenDev->ReleaseFont( font );

        }

    delete iFontCache;

    // screen device

    iWsScreenDev = NULL;

    // unload resource file

    CCoeEnv* coeEnv=CCoeEnv::Static();

    coeEnv->DeleteResourceFile(iResourceFileOffset);

    }

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

// CGDIDeviceContext::SwapColorBytes

//

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

//

NW_GDI_Color_t

CGDIDeviceContext::SwapColorBytes(NW_GDI_Color_t aColor)

{

  return NW_GDI_RGB(NW_GDI_GetBValue(aColor), NW_GDI_GetGValue(aColor), NW_GDI_GetRValue(aColor));

}

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

// CGDIDeviceContext::Epoc32GraphicsContext

//

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

//

CBitmapContext*

CGDIDeviceContext::Epoc32GraphicsContext ()

{

  return (CBitmapContext*)(iGraphicsContext);

}

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

// CGDIDeviceContext::WordWrap

// If a zero length string is passed in, KBrsrSuccess is returned and *length = 0

// If constraint is -1 return the smallest string that can split and KBrsrSuccess

//

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

//

TBrowserStatusCode

CGDIDeviceContext::WordWrap (NW_Text_t* aText,

                             CGDIFont* aGDIFont,

                             NW_GDI_Metric_t aConstraint,

                             NW_GDI_Metric_t aSpacing,

                             NW_GDI_FlowDirection_t aFlowDirection,

                             NW_Text_Length_t* aLength)

  {

  NW_REQUIRED_PARAM(aSpacing);

  NW_Text_Length_t strLen;

  NW_Text_Length_t i;

  TText16 ch1 = 0;

  TText16 ch2 = 0;

  TText16* string = NULL;

  TBool freeNeeded = NW_FALSE;

  TPtrC ptr;

  TBidiText *bidiText = NULL;

  CFont* epocFont = NULL;

  strLen = NW_Text_GetCharCount (aText);

  if (strLen == 0)

    {

    *aLength = 0;

    return KBrsrSuccess;

    }

  if (aConstraint == -1)

    {

    if (strLen > 1)

      {

      ch1 = (TText16)NW_Text_GetAt (aText, 0);

      for (i = 1; i < strLen; i++)

        {

        ch2 = (TText16)NW_Text_GetAt (aText, i);

        if (CanSplit(ch1, ch2))

          {

          *aLength = (NW_Text_Length_t)(i);

          return KBrsrSuccess;

          }

        ch1 = ch2;

        }

      }

    *aLength = strLen;

    return KBrsrSuccess;

    }

  if (aConstraint == 0)

    {

    *aLength = 0;

    return KBrsrLmgrNoSplit;

    }

  NW_TRY(status)

    {

    string = NW_Text_GetUCS2Buffer (aText,

        NW_Text_Flags_NullTerminated | NW_Text_Flags_Aligned | NW_Text_Flags_Copy,

        &strLen, (unsigned char*) &freeNeeded );

    for (i = 0; i < strLen; i++)

      {

      if (!NW_Str_Isspace((TText16)string[i]) && (string[i] != 0))

        {

        break;

        }

      }

    if (i == strLen)

      {

      *aLength = i;

      NW_THROW_SUCCESS(status);

      }

    ptr.Set(string, strLen);

    TRAPD(ret, bidiText = TBidiText::NewL(ptr, 1, (aFlowDirection == NW_GDI_FlowDirection_LeftRight) ?

        TBidiText::ELeftToRight : TBidiText::ERightToLeft));

    if (ret != KErrNone)

      {

      NW_THROW_STATUS (status, KBrsrOutOfMemory);

      }

    epocFont = (CFont*)aGDIFont->GetEpocNativeFont();

    bidiText->WrapText(aConstraint, *epocFont, 0);

    *aLength = bidiText->DisplayText().Length();

	//Solution for bug in TBidiText::WrapText for long text

	if(aFlowDirection == NW_GDI_FlowDirection_LeftRight)

	{

		NW_GDI_Dimension2D_t extent;

		status = GetSubstringExtent (aText,

									 aGDIFont,

									 0,

									 *aLength,

									 aSpacing,

									 aFlowDirection,

									 &extent);

		NW_THROW_ON_ERROR(status);

		if(extent.width > aConstraint)

		{

			extent.width = 0;

			NW_Text_Length_t len = 0;

			while(extent.width < aConstraint)

			{

				len++;

				status = GetSubstringExtent(aText, aGDIFont, 0, len, aSpacing, aFlowDirection, &extent);

				NW_THROW_ON_ERROR(status);

			}

			*aLength = len -1;

		}

	}

	//The above solution is to fix a Symbian bug in TBidiText::WrapText for long text

    delete bidiText;

    if (*aLength == 0)

      {

      NW_THROW_STATUS(status, KBrsrLmgrNoSplit);

      }

    if (*aLength < strLen)

      {

      // If the next character is a soft hyphen, add it to the aText

      if (string[*aLength] == NW_TEXT_UCS2_SOFT_HYPHEN)

        {

        (*aLength)++;

        NW_THROW_SUCCESS(status);

        }

      // TBidiText always omits the last space. see if we can add it back

      if ((*aLength) + 1 == strLen && NW_Str_Isspace(string[*aLength]))

        {

        NW_GDI_Dimension2D_t extent;

        status = GetSubstringExtent (aText,

                                     aGDIFont,

                                     0,

                                     *aLength,

                                     aSpacing,

                                     aFlowDirection,

                                     &extent);

        NW_THROW_ON_ERROR(status);

        if (extent.width <= aConstraint)

          {