/*

* Copyright (c) 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:  Contains all CSS styles

*

*/

// INCLUDE FILES

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

#include <f32file.h>

#include "nw_css_defaultstylesheet.h"

#include <nwx_assert.h>

#include "nwx_settings.h"

#include "nwx_ctx.h"

#include "nwx_logger.h"

#include "CSSReader.h"

#include "CSSPropVal.h"

#include "CSSDeclListHandle.h"

#include "CSSVariableStyleSheet.h"

#include "nw_xhtml_xhtml_1_0_tokens.h"

#include <bldvariant.hrh>

#include <data_caging_path_literals.hrh>

// ================================= CONSTANTS ====================================

#define ASCII_LEFT_BRACE          '{'

#define ASCII_RIGHT_BRACE         '}'

#define ASCII_NULL                '\0'

static const NW_Ucs2 CSS_CURLY_BRACES[] = {ASCII_LEFT_BRACE, ASCII_RIGHT_BRACE, ASCII_NULL};

/* User Supplied Style Sheet

 * The user can provide a style sheet that will override the operator

 * provided one.

 * The user provided sheet is stored in the emulator at:

 *      K:\epoc32\wins\c\System\data

 * The operator provided sheet is stored in the emulator at:

 *      K:\epoc32\release\wins\udeb\z\system\data

 *

 * Note that since 3.0, these location will change as defined in

 * data_caging_path_literals.hrh

 */

void CCSSVariableStyleSheet::ConstructCSSFileName()

{

   // Literals for files ( drive, directory, filename(s) )

	_LIT(KZDrive,"z:");

	_LIT(KCDrive,"c:");

	// _LIT(KDC_APP_RESOURCE_DIR,"\\resource\\apps\\uiresourcefiles\\");	//	Application resource (.rsc)

	// _LIT(KDC_RESOURCE_FILES_DIR,"\\resource\\");				// 	Other resource files

	_LIT(KFileName,"oem.css");

	CSS_USER_SUPPLIED_FILE.Zero();

    CSS_USER_SUPPLIED_FILE += KCDrive;

    CSS_USER_SUPPLIED_FILE += KDC_RESOURCE_FILES_DIR;

    CSS_USER_SUPPLIED_FILE += KFileName;

    CSS_USER_SUPPLIED_FILE.ZeroTerminate();

	CSS_OPERATOR_SUPPLIED_FILE.Zero();

    CSS_OPERATOR_SUPPLIED_FILE += KZDrive;

    CSS_OPERATOR_SUPPLIED_FILE += KDC_RESOURCE_FILES_DIR;

    CSS_OPERATOR_SUPPLIED_FILE += KFileName;

    CSS_OPERATOR_SUPPLIED_FILE.ZeroTerminate();

}

#ifdef _DEBUG

static const NW_Ucs2 CSS_INVALID_TOKEN[] = {'*','E','R','R','O','R','*','\0'};

static const NW_Ucs2 CSS_VARIABLE[] = {'v','a','r','\0'};

static const NW_Ucs2 CSS_DEFAULT[] = {'d','e','f','\0'};

static const NW_Ucs2 CSS_HEX_FORMAT[] = {'0','x','%','6','.','6','X','\0'};

static const NW_Ucs2 CSS_FLOAT_FORMAT[] = {'%','1','0','f','\0'};

#define NW_XHTML_1_0_INDEX 1

#endif /* _DEBUG */

// ============================ CONSTRUCTOR/DESTRUCTOR ===============================

void CCSSVariableStyleSheet::operator=(const CCSSVariableStyleSheet& aObj){

NW_REQUIRED_PARAM( &aObj );

}

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

// Symbian two phase constructor.

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

void CCSSVariableStyleSheet::ConstructL()

{

  HBufC8* buffer = NULL;

  //Initially nothing is loaded.

  iStaticCSSLoaded = EFalse;

  iVariableCSSLoaded = EFalse;

  //Create the lists. Pick a course granularity, they will be compressed

  //after completion. Minimize churning as we add components.

  iPropList = new (ELeave) CCSSPropEntryList(10);

  iStringList = new (ELeave) CCSSStringEntryList(5);

  ConstructCSSFileName();

  buffer = ReadVariableCSSFile();

  AddDefaultStyleStrings();

  AddVariableStyles(buffer);

  AddDefaultStyleProperties();

  delete buffer;

#ifdef _DEBUG

  DumpVariableStyleSheet();

#endif /* _DEBUG */

}

CCSSVariableStyleSheet* CCSSVariableStyleSheet::NewL()

  {

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

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop();

  return self;

  }

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

// Destructor.

// Close and delete the lists. The destructors of each of the objects

// will be called implicitly as a result.

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

CCSSVariableStyleSheet::~CCSSVariableStyleSheet()

{

  TInt count;

  TInt index;

  //Walk through the RArray. For each entry, if it references a dynamic

  //entry (e.g. variable) delete the referenced object. Otherwise don't

  //do anything with the entry itself. Then close and delete the array.

  if (iPropList != NULL){

    count = iPropList->Count();

    for(index=0; index<count; index++){

      TCSSPropEntry& propEntry = iPropList->operator[](index);

      if (propEntry.variableEntry == TRUE){

        delete propEntry.entry->pattern;

        delete propEntry.entry;

      }

    }

    iPropList->Close();

    delete iPropList;

  }

  if (iStringList != NULL){

    count = iStringList->Count();

    for(index=0; index<count; index++){

      TCSSStringEntry& stringEntry = iStringList->operator[](index);

      if (stringEntry.variableEntry == TRUE){

        delete stringEntry.entry;

      }

    }

    iStringList->Close();

    delete iStringList;

  }

}

// ============================ PUBLIC METHODS ===============================

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

// CCSSVariableStyleSheet::CreateSingleton

//

// Creates the CCSSVariableStyleSheet singleton.

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

CCSSVariableStyleSheet* CCSSVariableStyleSheet::CreateSingleton()

{

  CCSSVariableStyleSheet* thisObj = CCSSVariableStyleSheet::GetSingleton();

  if (thisObj == NULL){

    TRAPD(ret, thisObj = CCSSVariableStyleSheet::NewL());

    if (ret != KErrNone)

      return NULL;

    TRAP(ret, NW_Ctx_Set(NW_CTX_VARIABLE_CSS, 0, (void*)thisObj));

    if (ret != KErrNone)

      return NULL;

  }

  return thisObj;

}

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

// CCSSVariableStyleSheet::DeleteSingleton

//

// Deletes the CCSSVariableStyleSheet singleton.

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

void CCSSVariableStyleSheet::DeleteSingleton()

{

  CCSSVariableStyleSheet* thisObj = CCSSVariableStyleSheet::GetSingleton();

  if (thisObj != NULL){

    delete thisObj;

    NW_Ctx_Set(NW_CTX_VARIABLE_CSS, 0, NULL);

  }

}

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

// CCSSVariableStyleSheet::GetSingleton

//

// Get the CCSSVariableStyleSheet singleton. If it doesn't already exist then returns null.

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

CCSSVariableStyleSheet* CCSSVariableStyleSheet::GetSingleton()

{

  CCSSVariableStyleSheet* thisObj = (CCSSVariableStyleSheet*) NW_Ctx_Get(NW_CTX_VARIABLE_CSS, 0);

  return thisObj;

}

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

// CCSSVariableStyleSheet::ApplyStyles

//

// Applies the combined default and variable styles.

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

TBrowserStatusCode

  CCSSVariableStyleSheet::ApplyStyles(NW_DOM_ElementNode_t* aElementNode,

                                     NW_LMgr_Box_t* aBox,

                                     NW_WBXML_Dictionary_t* aDictionary,

                                     const NW_Evt_Event_t* aEvent,

                                     NW_HED_DocumentNode_t* aDocNode,

                                     NW_HED_DomHelper_t* aDomHelper)

{

  const NW_CSS_DefaultStyleSheet_PropEntry_t* propertyVal;

  TInt index, numPropertyVals;

  NW_Uint16 tagToken;

  const TCSSPropertyTablePropEntry* propEntry;

  TBrowserStatusCode status = KBrsrSuccess;

  NW_LMgr_Property_t prop;

  CCSSNodeData nodeData;

  TCSSPropEntry startEntry;

  tagToken = NW_DOM_ElementNode_getTagToken(aElementNode);

  numPropertyVals = iPropList->Count();

  //The entries are in order based on a key comprised of the element token

  //and the element name. The old algorithm searched through the array

  //until it found the first element token that matched. This algorithm lets

  //the binary search algorithm of the array do the work of finding the first

  //element that matches, or at least where to start looking. The looking stops

  //when a key is found that is greater than the token OR the end of the array

  //is reached.

  //Create a dummy entry with a search key that starts with the first

  //entry (if it exists) for this token and a default name of 0. If no

  //entry exists we will start at the place it WOULD exist. The search

  //will fail quickly in that case.

  startEntry.key = (tagToken << 16) | 0;

  iPropList->FindInUnsignedKeyOrder(startEntry, index);

  for(; index < numPropertyVals; index++){

    NW_Byte *pattern;

    propertyVal = iPropList->operator[](index).entry;

    if (propertyVal->elementToken < tagToken)

      continue;

    if (propertyVal->elementToken > tagToken)

      return KBrsrSuccess;

    /* match pattern - if pattern matches apply style */

    pattern = propertyVal->pattern;

    if (pattern != NULL){

      NW_Uint32 numBytes;

      CCSSPatternMatcher patternMatcher(aDictionary, aDocNode, aDomHelper);

      TBool matched = EFalse;

      (void) NW_String_charBuffGetLength(pattern, HTTP_us_ascii, &numBytes);

      TCSSParser parser(pattern, numBytes, HTTP_us_ascii);

      TRAPD(ret, matched = patternMatcher.MatchPatternLazyL(aElementNode, &parser, pattern, aEvent, &nodeData));

      if (ret == KErrNoMemory)

        return KBrsrOutOfMemory;

      if (!matched)

        continue;

    }

    propEntry = TCSSPropertyTable::GetPropEntryByToken(propertyVal->name);

    if (propEntry == NULL)

      continue;

    status = InitProperty(propEntry, &prop, aBox, propertyVal->val, propertyVal->valType);

    if (status == KBrsrOutOfMemory)

      return status;

    if (status != KBrsrSuccess)

      continue;

    /*

     Rules are arranged by decreasing specificity. If a property is

     already present, it can be replaced only if the other property is

     marked important. All defaults are NOT important.

    */

	TInt ret;

    TRAP(ret, TCSSDeclListHandle::ApplyPropertyL(propEntry->tokenName, &prop, 1,

                                                  EFalse, NULL, aBox, ETrue));

    if ((prop.type == NW_CSS_ValueType_Text) ||(prop.type == NW_CSS_ValueType_Image)){

      NW_Object_Delete(prop.value.object);

    }

  }

  return status;

}

// ============================ PRIVATE METHODS ===============================

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

// CCSSVariableStyleSheet::ReadVariableCSSFile

//

// Loads the file into a buffer.

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

HBufC8*

CCSSVariableStyleSheet::ReadVariableCSSFile()

{

  HBufC8* buffer = NULL;

  if ((buffer = ReadFile(CSS_USER_SUPPLIED_FILE)) == NULL)

    {

      buffer = ReadFile(CSS_OPERATOR_SUPPLIED_FILE);

    }

  return buffer;

}

//Returns a HBufC8 with the contents of aFile

HBufC8*

CCSSVariableStyleSheet::ReadFile(const TDesC& aFile)

{

  RFs fs;

  RFile file;

  TInt size = 0;

  HBufC8* contents = NULL;

  if (fs.Connect() != KErrNone )

    return contents;

  if (file.Open(fs, aFile, EFileShareAny | EFileRead) != KErrNone )

    {

      fs.Close();

      return contents;

    }

  //The file exists, allocate enough space for the NULL termination later.

  file.Size(size);

  if ((size != 0) && ((contents = HBufC8::New(size + 4)) != NULL))

    {

      //We have opened the file and it has a non-zero size and we have allocated memory

      TPtr8 contentsPtr(contents->Des());

      if (file.Read(contentsPtr, size)!= KErrNone)

        {

          delete contents;

          contents = NULL;

        }

    }

  file.Close();

  fs.Close();

  return contents;

}

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

// CCSSVariableStyleSheet::AddVariableStyles

//

// Adds the variable styles to the default list.

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

TBool CCSSVariableStyleSheet::AddVariableStyles(HBufC8* aBuffer)

{

  iVariableCSSLoaded = EFalse;

  if (aBuffer != NULL)

    {

      iVariableCSSLoaded = ProcessBuffer(aBuffer->Ptr(), aBuffer->Length());

    }

  else

    {

      iVariableCSSLoaded = EFalse;

    }

  return iVariableCSSLoaded;

}

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

// CCSSVariableStyleSheet::ProcessBuffer

//

// Adds the variable styles to the default list.

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

TBool CCSSVariableStyleSheet::ProcessBuffer(const TUint8* aBuffer, TUint32 aLength)

{

  TInt index = 0;

  TInt size = 0;

  TUint32 charset = HTTP_us_ascii;

  CCSSRuleList* ruleList = NULL;

  CCSSRuleListElementEntry* entry = NULL;

  TCSSParser parser((TUint8*)aBuffer, aLength, charset) ;

  TRAPD(ret, ruleList = CCSSRuleList::NewL(NULL));

  if (ret != KErrNone)

    return EFalse;

  ruleList->SetDictionary((NW_WBXML_Dictionary_t *) &NW_XHTML_WBXMLDictionary);

  ruleList->ProcessBuffer((TText8*)aBuffer, aLength, charset, ETrue); // delete buffer with ruleList

  size = ruleList->GetSize();

  for (index = 0; index < size; index++)

    {

      entry = ruleList->GetElementRulesByIndex(index);

      if (entry != NULL)

        {

          UpdateList(&parser, entry->iRules, entry->iElementToken);

        }

    }

  delete ruleList;

  return ETrue;

}

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

// CCSSVariableStyleSheet::AddDefaultStyleStrings

//

// Adds the default style string to the default list.

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

void CCSSVariableStyleSheet::AddDefaultStyleStrings()

{

  NW_Uint32 numVals;

  NW_Ucs2** stringVals;

  const NW_CSS_DefaultStyleSheet_t* defaultCSS;

  NW_Uint32 index;

  TCSSStringEntry stringEntry;

  NW_Ucs2* stringVal;

  defaultCSS = &NW_CSS_DefaultStyleSheet;

  numVals = NW_CSS_DefaultStyleSheet_GetClassPart(defaultCSS).numStringVals;

  stringVals = (NW_Ucs2**)(NW_CSS_DefaultStyleSheet_GetClassPart(defaultCSS).stringVals);

  for(index = 0; index < numVals; index++)

    {

      // Decode all the data in this structure and add to the array.  No

      // duplicates are allowed. The variable stuff was already added so

      // this is a lower priority.

      stringEntry.variableEntry = EFalse;

      stringVal = stringVals[index];

      stringEntry.entry = stringVal;

      iStringList->Append(stringEntry);

    }

  iStaticCSSLoaded = ETrue;

}

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

// CCSSVariableStyleSheet::AddDefaultStyleProps

//

// Adds the default style properties to the default list.

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

void CCSSVariableStyleSheet::AddDefaultStyleProperties()

{

  NW_Uint32 numVals;

  NW_CSS_DefaultStyleSheet_PropEntry_s* propertyVals;

  const NW_CSS_DefaultStyleSheet_t* defaultCSS;

  NW_Uint32 index;

  TCSSPropEntry propEntry;

  defaultCSS = &NW_CSS_DefaultStyleSheet;

  numVals = NW_CSS_DefaultStyleSheet_GetClassPart(defaultCSS).numPropertyVals;

  propertyVals = (NW_CSS_DefaultStyleSheet_PropEntry_s*)(NW_CSS_DefaultStyleSheet_GetClassPart(defaultCSS).propertyVals);

  for(index = 0; index < numVals; index++)

    {

      // Decode all the data in this structure and add to the array.  No

      // duplicates are allowed. The variable stuff was already added so

      // this is a lower priority.

      propEntry.key = (propertyVals[index].elementToken <<16) | (propertyVals[index].name);

      propEntry.variableEntry = EFalse;

      propEntry.entry = &(propertyVals[index]);

      //Insert the property. If this was a duplicate we ignore it. Ignore return value

      InsertProperty(propEntry);

    }

  iStaticCSSLoaded = ETrue;

}

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

// CCSSVariableStyleSheet::InsertProperty

//

// Applies the styles to the property.

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

TInt CCSSVariableStyleSheet::InsertProperty(TCSSPropEntry aPropEntry)

{

  TCSSPropEntry compareEntry;

  TInt searchIndex;

  if (iPropList->FindInUnsignedKeyOrder(aPropEntry, searchIndex) == KErrNone){

    //A duplicate primary key was found. Check secondary key

    //(e.g. pattern) to see if this is really a duplicate. Only insert

    //if the pattern specified matches none of the existing ones.

    //Multiple entries with the same key exist. Walk back until we find

    //the first one. The binary search that returned this index doesn't

    //always return the first entry in the list of duplicate keys.

    while (searchIndex >= 0){

      compareEntry = iPropList->operator[](searchIndex);