X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=plugins%2Fdali-swig%2FSWIG%2Fdali-operator.i;h=894b34f0bd3d3f5d5fcba7d3e893cff6ef1720f1;hp=f6bbe4de7d3dc35f6f142f5bffe9ba07f8173d5a;hb=fc21bf19ca663759c47ef7b40efcc9ac79e4cf22;hpb=4973c9caa70ff6dd9e2bf91058a072b84e0f1e01

diff --git a/plugins/dali-swig/SWIG/dali-operator.i b/plugins/dali-swig/SWIG/dali-operator.i
index f6bbe4d..894b34f 100644
--- a/plugins/dali-swig/SWIG/dali-operator.i
+++ b/plugins/dali-swig/SWIG/dali-operator.i
@@ -252,7 +252,13 @@
  * This is because from C# we can't wrap the operator BooleanType() function
  */
 %extend Dali::BaseHandle {
-   bool IsHandleEmpty() const {
+   bool HasBody() const {
+
+     // C++ code. DALi uses Handle <-> Body design pattern.
+     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
+     // Handles in DALi can be converted into a boolean type
+     // to check if the handle has a valid body attached to it.
+     // Internally checking *$self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
      if( *$self )
      {
        return true;
@@ -262,6 +268,21 @@
        return false;
      }
     }
+
+     // Check if two handles point to the same body / ref-object.
+     bool IsEqual( const BaseHandle& rhs ) const {
+
+     // C++ code. Check if two handles reference the same implemtion
+     if( *$self == rhs)
+     {
+       return true;
+     }
+     else
+     {
+       return false;
+     }
+    }
+
 };
 
 /**
@@ -274,21 +295,114 @@
  */
 %typemap(cscode) Dali::BaseHandle %{
 
- public static bool operator true(BaseHandle  handle)
- {
-   if( handle!= null  )
-   {
-     return  handle.IsHandleEmpty();
-   }
-   else
-   {
-     return false;
-   }
- }
- public static bool operator false(BaseHandle  handle)
- {
-   return  handle.IsHandleEmpty();
- }
-%}
+  // Returns the bool value true to indicate that an operand is true and returns false otherwise.
+  public static bool operator true(BaseHandle handle)
+  {
+    // if the C# object is null, return false
+    if( BaseHandle.ReferenceEquals( handle, null ) )
+    {
+      return false;
+    }
+    // returns true if the handle has a body, false otherwise
+    return handle.HasBody();
+  }
+
+  // Returns the bool false  to indicate that an operand is false and returns true otherwise.
+  public static bool operator false(BaseHandle  handle)
+  {
+    // if the C# object is null, return true
+    if( BaseHandle.ReferenceEquals( handle, null ) )
+    {
+      return true;
+    }
+    return !handle.HasBody();
+  }
+
+  // Explicit conversion from Handle to bool.
+  public static explicit operator bool(BaseHandle handle)
+  {
+     // if the C# object is null, return false
+    if( BaseHandle.ReferenceEquals( handle, null ) )
+    {
+      return false;
+    }
+    // returns true if the handle has a body, false otherwise
+    return handle.HasBody();
+  }
 
+  // Equality operator
+  public static bool operator == (BaseHandle x, BaseHandle y)
+  {
+    // if the C# objects are the same return true
+    if(  BaseHandle.ReferenceEquals( x, y ) )
+    {
+      return true;
+    }
+    if ( !BaseHandle.ReferenceEquals( x, null ) && !BaseHandle.ReferenceEquals( y, null ) )
+    {
+      // drop into native code to see if both handles point to the same body
+      return x.IsEqual( y) ;
+    }
+    return false;
+
+  }
+
+  // Inequality operator. Returns Null if either operand is Null
+  public static bool operator !=(BaseHandle x, BaseHandle y)
+  {
+    return !(x==y);
+  }
+
+  // Logical AND operator for &&
+  // It's possible when doing a && this function (opBitwiseAnd) is never called due
+  // to short circuiting. E.g.
+  // If you perform x && y What actually is called is
+  // BaseHandle.op_False( x ) ? BaseHandle.op_True( x ) : BaseHandle.opTrue( BaseHandle.opBitwiseAnd(x,y) )
+  //
+  public static BaseHandle operator &(BaseHandle x, BaseHandle y)
+  {
+    if( x == y )
+    {
+      return x;
+    }
+    return null;
+  }
+
+  // Logical OR operator for ||
+  // It's possible when doing a || this function (opBitwiseOr) is never called due
+  // to short circuiting. E.g.
+  // If you perform x || y What actually is called is
+  // BaseHandle.op_True( x ) ? BaseHandle.op_True( x ) : BaseHandle.opTrue( BaseHandle.opBitwiseOr(x,y) )
+  public static BaseHandle operator |(BaseHandle x, BaseHandle y)
+  {
+    if ( !BaseHandle.ReferenceEquals( x, null ) || !BaseHandle.ReferenceEquals( y, null ) )
+    {
+       if( x.HasBody() )
+       {
+         return x;
+       }
+       if( y.HasBody() )
+       {
+         return y;
+       }
+       return null;
+    }
+    return null;
+  }
+
+  // Logical ! operator
+  public static bool operator !(BaseHandle x)
+  {
+    // if the C# object is null, return true
+    if( BaseHandle.ReferenceEquals( x, null ) )
+    {
+      return true;
+    }
+    if( x.HasBody() )
+    {
+      return false;
+    }
+    return true;
+  }
 
+%}
\ No newline at end of file