1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 #include "NPUtils.h"

    18 

    19 #include <utf.h>

    20 #include "CCPixNPPluginEcom.h"

    21 

    22 namespace nputils {

    23 

    24 

    25 // -----------------------------------------------------------------------------

    26 

    27 TInt VariantToInt( NPVariant& v )

    28     {

    29     if ( NPVARIANT_IS_INT32( v ) ) return NPVARIANT_TO_INT32( v );

    30     if ( NPVARIANT_IS_DOUBLE( v ) )

    31         {

    32         TReal value = NPVARIANT_TO_DOUBLE( v );

    33         if (value > 0) return value + 0.5; 

    34         return value - 0.5;

    35         }

    36     if ( NPVARIANT_IS_BOOLEAN( v ) ) return NPVARIANT_TO_BOOLEAN( v );

    37     return 0;

    38     }

    39 

    40 // -----------------------------------------------------------------------------

    41 

    42 TUint VariantToUnsigned( NPVariant& v )

    43     {

    44     TInt value = 0;

    45     if ( NPVARIANT_IS_INT32( v ) ) value = NPVARIANT_TO_INT32( v );

    46     if ( NPVARIANT_IS_DOUBLE( v ) ) value = NPVARIANT_TO_DOUBLE( v ) + 0.5;

    47     if ( NPVARIANT_IS_BOOLEAN( v ) ) value = NPVARIANT_TO_BOOLEAN( v );

    48     if (value < 0) return 0;

    49     return value;

    50     }

    51 

    52 // -----------------------------------------------------------------------------

    53 

    54 TReal VariantToDouble( NPVariant& v )

    55     {

    56     if ( NPVARIANT_IS_INT32( v ) ) return NPVARIANT_TO_INT32( v );

    57     if ( NPVARIANT_IS_DOUBLE( v ) ) return NPVARIANT_TO_DOUBLE( v );

    58     if ( NPVARIANT_IS_BOOLEAN( v ) ) return NPVARIANT_TO_BOOLEAN( v );

    59     return 0;

    60     }

    61 

    62 // -----------------------------------------------------------------------------

    63 

    64 void DescriptorToVariantL(const TDesC16& aString, NPVariant& aVariant)

    65 	{

    66     CCPixNPPluginEcom* pluginEcom = (CCPixNPPluginEcom*) Dll::Tls();

    67     NPNetscapeFuncs* netscapeFuncs = pluginEcom->Funcs();

    68     

    69     HBufC8* utf8String = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aString);

    70     int length = utf8String->Length();

    71         

    72     char* newString = (char *)netscapeFuncs->memalloc( length );

    73     if (newString)

    74     	{

    75         Mem::Copy(newString, utf8String->Des().Ptr(), length);

    76         STRINGN_TO_NPVARIANT(newString, length, aVariant);

    77     	}

    78     delete utf8String;

    79 	}

    80 

    81 // -----------------------------------------------------------------------------

    82 

    83 void DescriptorToVariant(const TDesC8& aString, NPVariant& aVariant)

    84     {

    85     CCPixNPPluginEcom* pluginEcom = (CCPixNPPluginEcom*) Dll::Tls();

    86     NPNetscapeFuncs* netscapeFuncs = pluginEcom->Funcs();

    87     

    88     int length = aString.Length();

    89     char* newString = (char *)netscapeFuncs->memalloc( length );

    90     

    91     if (newString)

    92         {

    93         Mem::Copy(newString, aString.Ptr(), length);

    94         STRINGN_TO_NPVARIANT(newString, length, aVariant);

    95         }

    96     }

    97 

    98 // -----------------------------------------------------------------------------

    99 

   100 void VariantToDescriptor(NPVariant& aVariant, TDes8& aString)

   101     {

   102     if ( !NPVARIANT_IS_STRING(aVariant) ) return;

   103     NPString string = NPVARIANT_TO_STRING(aVariant);

   104     aString.Copy((TUint8*)string.UTF8Characters, string.UTF8Length);

   105     }

   106 

   107 // -----------------------------------------------------------------------------

   108 

   109 void VariantToDescriptorL(NPVariant& aVariant, TDes16& aString)

   110     {

   111     if ( !NPVARIANT_IS_STRING(aVariant) ) return;

   112     NPString string = NPVARIANT_TO_STRING(aVariant);

   113     RBuf8 buffer;

   114     buffer.CreateL(string.UTF8Length);

   115     buffer.Copy((TUint8*)string.UTF8Characters, string.UTF8Length);

   116     CnvUtfConverter::ConvertToUnicodeFromUtf8(aString, buffer);

   117     buffer.Close();

   118     }

   119 

   120 HBufC16* VariantToHBufC16LC(NPVariant& aVariant)

   121     {

   122     if ( !NPVARIANT_IS_STRING(aVariant) ) return NULL; 

   123     NPString string = NPVARIANT_TO_STRING(aVariant);

   124     RBuf8 buffer;

   125     buffer.CreateL(string.UTF8Length);

   126     CleanupClosePushL( buffer ); 

   127     buffer.Copy((TUint8*)string.UTF8Characters, string.UTF8Length);

   128     HBufC16* ret = CnvUtfConverter::ConvertToUnicodeFromUtf8L( buffer );

   129     CleanupStack::PopAndDestroy(); // buffer ;

   130     CleanupStack::PushL( ret ); 

   131     return ret; 

   132     }

   133 

   134 HBufC8* VariantToHBufC8LC(NPVariant& aVariant)

   135     {

   136     if ( !NPVARIANT_IS_STRING(aVariant) ) return NULL; 

   137     HBufC8* ret = HBufC8::NewLC( NPVARIANT_TO_STRING( aVariant ).UTF8Length );

   138     TPtr8 des( ret->Des() );

   139     VariantToDescriptor( aVariant, des ); 

   140     return ret; 

   141     }

   142 

   143 }

   144