Added or'd enums to scripting

Change-Id: I2ccbf1a549d49ff3acfef9f59c1dd59967bb751a

diff --git a/automated-tests/src/dali-devel/utc-Dali-Scripting.cpp b/automated-tests/src/dali-devel/utc-Dali-Scripting.cpp
index b3596a2..e481b2a 100644 (file)
--- a/automated-tests/src/dali-devel/utc-Dali-Scripting.cpp
+++ b/automated-tests/src/dali-devel/utc-Dali-Scripting.cpp
@@ -1025,6 +1025,68 @@ int UtcDaliScriptingGetLinearEnumerationNameN(void)
 int UtcDaliScriptingFindEnumIndexN(void)
 {
   const Scripting::StringEnum myTable[] =
+    {
+      { "ONE",    (1<<1) },
+      { "TWO",    (1<<2) },
+      { "THREE",  (1<<3) },
+      { "FOUR",   (1<<4) },
+      { "FIVE",   (1<<5) },
+    };
+  const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+  DALI_TEST_EQUALS( myTableCount, FindEnumIndex( "Foo", myTable, myTableCount ), TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliScriptingEnumStringToIntegerP(void)
+{
+  const Scripting::StringEnum myTable[] =
+    {
+      { "ONE",    (1<<1) },
+      { "TWO",    (1<<2) },
+      { "THREE",  (1<<3) },
+      { "FOUR",   (1<<4) },
+      { "FIVE",   (1<<5) },
+    };
+  const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+
+  unsigned int integerEnum = 0;
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE", myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
+
+  integerEnum = 0;
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE,,TWO", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO,THREE", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO,THREE,FOUR,FIVE", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "TWO,ONE", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "TWO,ONE,FOUR,THREE,FIVE", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE,SEVEN", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
+
+  DALI_TEST_CHECK( EnumStringToInteger( "ONE,", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
+
+
+  END_TEST;
+}
+
+int UtcDaliScriptingEnumStringToIntegerN(void)
+{
+  const Scripting::StringEnum myTable[] =
   {
     { "ONE",    1 },
     { "TWO",    2 },
@@ -1033,7 +1095,66 @@ int UtcDaliScriptingFindEnumIndexN(void)
     { "FIVE",   5 },
   };
   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
-  DALI_TEST_EQUALS( myTableCount, FindEnumIndex( "Foo", myTable, myTableCount ), TEST_LOCATION );
+
+  unsigned int integerEnum = 0;
+  DALI_TEST_CHECK( !EnumStringToInteger( "Foo", myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( "", myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( ",", myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( ",ONE,SEVEN", myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( ",", myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( "ONE", myTable, 0, integerEnum ) );
+
+  DALI_TEST_EQUALS( integerEnum, 0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliScriptingEnumStringToIntegerInvalidEnumP(void)
+{
+  const Scripting::StringEnum myTable[] =
+  {
+    { "",    1 },
+    { "",    2 },
+    { "",    3 },
+  };
+
+  const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+
+  unsigned int integerEnum = 0;
+  DALI_TEST_CHECK( EnumStringToInteger( "", myTable, myTableCount, integerEnum ) );
+  DALI_TEST_EQUALS( integerEnum, 1, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliScriptingEnumStringToIntegerInvalidEnumN(void)
+{
+  const Scripting::StringEnum myTable[] =
+  {
+    { "",    1 },
+    { "",    1 },
+    { "",    1 },
+  };
+
+  const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+
+  unsigned int integerEnum = 0;
+  DALI_TEST_CHECK( !EnumStringToInteger( NULL, NULL, 0, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( "ONE", NULL, 0, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( NULL, myTable, 0, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( NULL, myTable, myTableCount, integerEnum ) );
+
+  DALI_TEST_CHECK( !EnumStringToInteger( "ONE", NULL, myTableCount, integerEnum ) );
+
+  DALI_TEST_EQUALS( integerEnum, 0, TEST_LOCATION );
 
   END_TEST;
 }

diff --git a/dali/devel-api/scripting/scripting.cpp b/dali/devel-api/scripting/scripting.cpp
index 9796b48..33a3891 100644 (file)
--- a/dali/devel-api/scripting/scripting.cpp
+++ b/dali/devel-api/scripting/scripting.cpp
@@ -154,10 +154,12 @@ const char* ImageTypeName[] = { "ResourceImage", "FrameBufferImage", "BufferImag
 enum ImageType                { RESOURCE_IMAGE,  FRAME_BUFFER_IMAGE, BUFFER_IMAGE };
 const unsigned int imageTypeCount = sizeof( ImageTypeName ) / sizeof( const char* );
 
-bool CompareEnums( const char * a, const char * b )
+bool CompareEnums( const char * a, const char * b, size_t& size )
 {
-  while( ( *a != '\0' ) && ( *b != '\0' ) )
+  size = 0;
+  while( ( *a != '\0' ) && ( *b != '\0' ) && ( *a != ',') && ( *b != ',') )
   {
+    ++size;
     char ca = *a;
     char cb = *b;
 
@@ -188,7 +190,10 @@ bool CompareEnums( const char * a, const char * b )
     ++b;
   }
 
-  if( ( *a == '\0' ) && ( *b == '\0' ) )
+  // enums can be comma separated so check ends and comma
+  if( ( ( *a == '\0' ) && ( *b == '\0' ) ) ||
+      ( ( *a == '\0' ) && ( *b == ','  ) ) ||
+      ( ( *a == ','  ) && ( *b == '\0' ) ) )
   {
     return true;
   }
@@ -198,13 +203,66 @@ bool CompareEnums( const char * a, const char * b )
 
 } // unnamed namespace
 
+bool EnumStringToInteger( const char * const value, const StringEnum* const enumTable, unsigned int tableCount, unsigned int& integerEnum )
+{
+  unsigned int ret = 0;
+
+  bool found = false;
+  bool done = false;
+
+  if( value && enumTable && tableCount )
+  {
+    const char* pValue = value;
+
+    while(!done)
+    {
+      size_t size = 0;
+
+      const StringEnum* table = enumTable;
+
+      for ( unsigned int i = 0; i < tableCount; ++i )
+      {
+        if( CompareEnums( pValue, table->string, size ) )
+        {
+          found = true;
+          ret |= table->value;
+          break;
+        }
+        table++;
+      }
+
+      done = true;
+
+      if(found)
+      {
+        // allow comma separated or'd value
+        if( *(pValue+size) == ',' )
+        {
+          pValue += size + 1;
+          done = false;
+        }
+      }
+
+    }
+
+    integerEnum = ret;
+  }
+
+  if ( !found )
+  {
+    DALI_LOG_ERROR( "Unknown enumeration string %s\n", value );
+  }
+  return found;
+}
+
 unsigned int FindEnumIndex( const char* value, const StringEnum* table, unsigned int tableCount )
 {
   unsigned int index = 0;
   bool found = false;
   for ( unsigned int i = 0; i < tableCount; ++i, ++index )
   {
-    if( CompareEnums( value, table->string ) )
+    size_t sizeIgnored = 0;
+    if( CompareEnums( value, table->string, sizeIgnored ) )
     {
       found = true;
       break;
@@ -281,7 +339,8 @@ Vector3 GetAnchorConstant( const std::string& value )
 {
   for( unsigned int i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
   {
-    if( CompareEnums( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name ) )
+    size_t sizeIgnored = 0;
+    if( CompareEnums( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
     {
       return ANCHOR_CONSTANT_TABLE[ i ].value;
     }

diff --git a/dali/devel-api/scripting/scripting.h b/dali/devel-api/scripting/scripting.h
index a03a73b..1a42e17 100644 (file)
--- a/dali/devel-api/scripting/scripting.h
+++ b/dali/devel-api/scripting/scripting.h
@@ -58,9 +58,22 @@ struct StringEnum
 DALI_IMPORT_API unsigned int FindEnumIndex( const char* value, const StringEnum* table, unsigned int tableCount );
 
 /**
+ * @brief Find the enum as an integer from the table
+ *
+ * @since 1.1.12
+ *
+ * @param[in]  value       The string equivalent (case-insensitive, comma separate to OR values).
+ * @param[in]  table       A pointer to an array with the enumeration to string equivalents.
+ * @param[in]  tableCount  Number of items in the array.
+ * @param[out] integerEnum The value of the enum.
+ * @return     true if one or more enums in value.
+ */
+DALI_IMPORT_API bool EnumStringToInteger( const char* const value, const StringEnum* const table, unsigned int tableCount, unsigned int& integerEnum );
+
+/**
  * @brief Chooses the appropriate enumeration for the provided string from the given table.
  *
- * @param[in]  value       The string equivalent (case-insensitive).
+ * @param[in]  value       The string equivalent (case-insensitive, comma separate to OR values).
  * @param[in]  table       A pointer to an array with the enumeration to string equivalents.
  * @param[in]  tableCount  Number of items in the array.
  * @param[out] result      The enum value
@@ -73,11 +86,11 @@ bool GetEnumeration( const char* value, const StringEnum* table, unsigned int ta
   bool retVal( false );
   if( table )
   {
-    unsigned int index = FindEnumIndex( value, table, tableCount );
+    unsigned int integerEnum = 0;
     // check to avoid crash, not asserting on purpose, error is logged instead
-    if( index < tableCount )
+    if( EnumStringToInteger( value, table, tableCount, integerEnum ) )
     {
-      result = static_cast<T>( table[ index ].value );
+      result = static_cast<T>( integerEnum );
       retVal = true;
     }
   }