/*

* Copyright (c) 2006, 2007 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:  This class parses the dps xml script. 

*

*/

#include "dpsxmlparser.h"

#include "dpsconst.h"

#include "pictbridge.h"

#include "dpsxmlstring.h"

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

// 

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

//

CDpsXmlParser* CDpsXmlParser::NewL(CDpsEngine* aEngine)

	{

    CDpsXmlParser* self = new (ELeave) CDpsXmlParser(aEngine);

    return self;

    }

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

// 

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

//	

CDpsXmlParser::~CDpsXmlParser()

    {

    iDpsArgs.Close();

    }

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

// 

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

//	

CDpsXmlParser::CDpsXmlParser(CDpsEngine* aEngine) : iEngine(aEngine)

    {

	Reset();

	}

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

// 

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

//

void CDpsXmlParser::OnStartDocumentL(

		const RDocumentParameters& /*aDocParam*/, TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

	}

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

// 

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

//

void CDpsXmlParser::OnEndDocumentL(TInt aErrorCode)

	{

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    }

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

// 

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

//	

void CDpsXmlParser::OnStartElementL(const RTagInfo& aElement, 

									const RAttributeArray& aAttributes, 

									TInt aErrCode)

    {

    if (aErrCode != KErrNone)

        {

        User::Leave(aErrCode);

        }

    if (aAttributes.Count() > 1)

        {

        User::Leave(KErrArgument);

        }

    // Gets the name of the tag

    const TDesC8& name = aElement.LocalName().DesC();

    //Checks the element

    // this is the first layer <dps>

    if (!name.Compare(KDpsXml))

        {

        iAction = EDpsXmlStart;

        }

    // this is the second layer	<input|output>

    else if (!name.Compare(KDpsXmlOutput))

        {

        iAction = EDpsXmlOutput;

        }

    else if (!name.Compare(KDpsXmlInput))

        {

        // operation and event cannot be distiguised here

        iAction = EDpsXmlInput;

        }

    // this is the third layer <operation|event|result>	

    else if (iAction == EDpsXmlOutput && !name.Compare(KDpsXmlResult))

        {

        // output must be result

        iAction = EDpsXmlResult;

        }		

    else if (iAction == EDpsXmlInput &&

        (!name.Compare(iEngine->DpsParameters()->iDpsEventStrings[0]) ||

        !name.Compare(iEngine->DpsParameters()->iDpsEventStrings[1])))

        {

        if (!name.Compare(iEngine->DpsParameters()->iDpsEventStrings[0]))

            {

            iDpsEvent = EDpsEvtNotifyJobStatus;

            }

        else

            {

            iDpsEvent = EDpsEvtNotifyDeviceStatus;	

            }

        iAction = EDpsXmlEvent;	

        }

    else if (iAction == EDpsXmlInput || iAction == EDpsXmlResult)

        {

        iAction = EDpsXmlOperation;

        for (TInt i= 0; i < EDpsOpMax-1; i++) //i=0 as AppendL() method adds item on first free position in array

            {

            if (!name.Compare(iEngine->DpsParameters()->iDpsOperationStrings[i]))

                {

                iDpsOperation = (TDpsOperation)(i+1);// i+1 to by pass first operation EDpsOpEmpty in enum which is not added to array

                break;

                }

            }

        }

    // below is the fourth layer, e.g. the argument list/element. there

    // could be many arugments, but only one element	

    else if (iAction == EDpsXmlOperation || iAction == EDpsXmlEvent)

        {

        // only element in output is capability

        if (!name.Compare(iEngine->DpsParameters()->iDpsElementStrings[0]))

            {

            iElement = EDpsCapability;

            }

        else

            {

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

                {

                if (!name.Compare(iEngine->DpsParameters()->iDpsArgStrings[i]))

                    {

                    TDpsArg arg;

                    arg.iElement = (TDpsArgument)i;

                    arg.iContent.Copy(_L(""));

                    iDpsArgs.Append(arg);

                    break;

                    }

                }

            }

        }

    else

        {

        // something wrong

        User::Leave(KErrNotSupported);

        }

    if (aAttributes.Count() == 1)

        {

        ParseAttributesL(aAttributes, name);

        }

    }

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

// 

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

//	     

void CDpsXmlParser::ParseAttributesL(const RAttributeArray& aAttributes, 

                                     const TDesC8& tag)

    {

    // element

    const TDesC8& name = aAttributes[0].Attribute().LocalName().DesC();

    // only "layouts" and "paperTypes" have attributes

    if (tag.Compare(KDpsXmlPaperTypes) && tag.Compare(KDpsXmlLayouts))

        {

        // error

        User::Leave(KErrArgument);

        }

    // the element of the attributes must be "paperSize"	

    if (name.Compare(KDpsXmlPaperSize))

        {

        // error

        User::Leave(KErrArgument);

        }

    // value

    HBufC8* value = aAttributes[0].Value().DesC().AllocLC();

    TUint32 result;    

    TLex8 converter(*value);

    TInt error = converter.Val(result, EHex);

    if (error != KErrNone)

        {

        User::Leave(error);

        }

    iAttrib = result >> KShiftLength; 

    CleanupStack::PopAndDestroy(value);

    }

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

// 

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

//	

void CDpsXmlParser::OnEndElementL(const RTagInfo& aElement, 

								  TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    // Get the name of the tag

    const TDesC8& name = aElement.LocalName().DesC();

    }

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

// 

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

//

void CDpsXmlParser::OnContentL(const TDesC8& aBytes, TInt aErrorCode)

	{

    if (aErrorCode != KErrNone)

   	    {

        User::Leave(aErrorCode);

        }	

    if (aBytes[0] >= KSOH && aBytes[0] <= KSpace)

        {

        return; 

        }

    // parses the result	

    if (iAction == EDpsXmlResult)

        {

        TUint32 value;

        TLex8 converter(aBytes);

        TInt error = converter.Val(value, EHex);

        if (error != KErrNone)

            {

            User::Leave(error);

            }

        // we have got the result

        iDpsResult.iMajorCode = 

            static_cast<TDpsResultMajorCode>(value >> KShiftLength);

        iDpsResult.iMinorCode = 

            static_cast<TDpsResultMinorCode>(value & KDpsMinorMask);

        }

    // gets the argument	

    else if (iAction == EDpsXmlOperation || iAction == EDpsXmlEvent)

        {

        iDpsArgs[iDpsArgs.Count() - 1].iContent.Copy(aBytes);

        }

    }

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

// 

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

//

void CDpsXmlParser::OnStartPrefixMappingL(const RString& /*aPrefix*/, 

										  const RString& /*aUri*/, 

										  TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    }

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

// 

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

//	

void CDpsXmlParser::OnEndPrefixMappingL(const RString& /*aPrefix*/, 

									    TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    }

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

// 

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

//

void CDpsXmlParser::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, 

                                           TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    }

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

// 

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

//	

void CDpsXmlParser::OnSkippedEntityL(const RString& /*aName*/, 

								     TInt aErrorCode)

	{

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    }

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

// 

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

//	

void CDpsXmlParser::OnProcessingInstructionL(const TDesC8& /*aTarget*/, 

											 const TDesC8& /*aData*/, 

											 TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        User::Leave(aErrorCode);

        }

    }

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

// 

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

//	

void CDpsXmlParser::OnError(TInt aErrorCode)

    {

    if (aErrorCode != KErrNone)

        {

        }

    }

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

// 

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

//	

TAny* CDpsXmlParser::GetExtendedInterface(const TInt32 aUid)

    {

    return aUid == MDpsExtensionHandler::EInterfaceUid ?

    static_cast<MDpsExtensionHandler*>(this) : 0;

    }

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

// 

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

//  

void CDpsXmlParser::Reset()

    {

    iDpsArgs.Reset();

    iAction = EDpsXmlEmpty;

    iDpsEvent = EDpsEvtEmpty; 

    iDpsOperation = EDpsOpEmpty;

    iElement = EDpsEleEmpty; 

    iAttrib = 0;

    }