X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=base%2Fdali-toolkit%2Finternal%2Fcontrols%2Ftable-view%2Ftable-view-impl.cpp;h=85099f53f959187e55ec2f8f84280a54169426ae;hb=00fa69a5c227121632d355bafecbbed5266f94ec;hp=7f760dbe747529d5cd94f0cdc92d2a0321a37453;hpb=d5e3ed5f5b1c8fdba3ae97ead8729620f54b3836;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/base/dali-toolkit/internal/controls/table-view/table-view-impl.cpp b/base/dali-toolkit/internal/controls/table-view/table-view-impl.cpp
index 7f760db..85099f5 100644
--- a/base/dali-toolkit/internal/controls/table-view/table-view-impl.cpp
+++ b/base/dali-toolkit/internal/controls/table-view/table-view-impl.cpp
@@ -17,24 +17,20 @@
 
 // CLASS HEADER
 #include <dali-toolkit/internal/controls/table-view/table-view-impl.h>
-#include <dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h>
 
 // EXTERNAL INCLUDES
+#include <sstream>
+#include <dali/public-api/animation/constraint.h>
+#include <dali/public-api/animation/time-period.h>
 #include <dali/public-api/object/ref-object.h>
-#include <dlog.h>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/scripting/scripting.h>
+#include <dali/integration-api/debug.h>
 
 using namespace Dali;
-using namespace std;
 
 namespace
 {
-// Type registration
-BaseHandle Create()
-{
-  return Toolkit::TableView::New(0, 0);
-}
-TypeRegistration mType( typeid(Toolkit::TableView), typeid(Toolkit::Control), Create );
-
 const float DEFAULT_CONSTRAINT_DURATION = 0.0f;
 
 /**
@@ -76,8 +72,8 @@ struct RelativeToWidthOrHeight
 // debugging support, very useful when new features are added or bugs are hunted down
 // currently not called from code so compiler will optimize these away, kept here for future debugging
 
-#define TABLEVIEW_TAG "DALI Toolkit::TableView"
-#define TV_LOG(fmt, args...) LOG(LOG_INFO, TABLEVIEW_TAG, fmt, ## args)
+#define TABLEVIEW_TAG "DALI Toolkit::TableView "
+#define TV_LOG(fmt, args...) Debug::LogMessage(Debug::DebugInfo, TABLEVIEW_TAG fmt, ## args)
 
 void PrintArray( Array2d<Dali::Toolkit::Internal::TableView::CellData>& array )
 {
@@ -118,7 +114,7 @@ void PrintArray( Array2d<Size>& array )
 }
 // debugging support, very useful when new features are added or bugs are hunted down
 // currently not called from code so compiler will optimize these away, kept here for future debugging
-void PrintVector( vector<float>& array )
+void PrintVector( std::vector<float>& array )
 {
   TV_LOG( "vector, size [%d]\n", array.size() );
   // print values
@@ -138,9 +134,44 @@ namespace Dali
 namespace Toolkit
 {
 
+const Property::Index TableView::PROPERTY_ROWS( Internal::TableView::TABLEVIEW_PROPERTY_START_INDEX );
+const Property::Index TableView::PROPERTY_COLUMNS( Internal::TableView::TABLEVIEW_PROPERTY_START_INDEX + 1 );
+const Property::Index TableView::PROPERTY_CELL_PADDING( Internal::TableView::TABLEVIEW_PROPERTY_START_INDEX + 2 );
+const Property::Index TableView::PROPERTY_LAYOUT_ANIMATION_DURATION( Internal::TableView::TABLEVIEW_PROPERTY_START_INDEX + 3 );
+const Property::Index TableView::PROPERTY_LAYOUT_ROWS( Internal::TableView::TABLEVIEW_PROPERTY_START_INDEX + 4 );
+const Property::Index TableView::PROPERTY_LAYOUT_COLUMNS( Internal::TableView::TABLEVIEW_PROPERTY_START_INDEX + 5 );
+
 namespace Internal
 {
 
+namespace
+{
+
+const Scripting::StringEnum< Toolkit::TableView::LayoutPolicy > LAYOUT_POLICY_STRING_TABLE[] =
+{
+ { "fixed",    Toolkit::TableView::Fixed    },
+ { "relative", Toolkit::TableView::Relative },
+ { "fill",     Toolkit::TableView::Fill }
+};
+
+const unsigned int LAYOUT_POLICY_STRING_TABLE_COUNT = sizeof(LAYOUT_POLICY_STRING_TABLE) / sizeof( LAYOUT_POLICY_STRING_TABLE[0] );
+
+// Type registration
+BaseHandle Create()
+{
+  return Toolkit::TableView::New(0, 0);
+}
+TypeRegistration mType( typeid(Toolkit::TableView), typeid(Toolkit::Control), Create );
+
+PropertyRegistration property1( mType, "rows", Toolkit::TableView::PROPERTY_ROWS, Property::UNSIGNED_INTEGER, &TableView::SetProperty, &TableView::GetProperty );
+PropertyRegistration property2( mType, "columns", Toolkit::TableView::PROPERTY_COLUMNS, Property::UNSIGNED_INTEGER, &TableView::SetProperty, &TableView::GetProperty );
+PropertyRegistration property3( mType, "cell-padding", Toolkit::TableView::PROPERTY_CELL_PADDING, Property::VECTOR2, &TableView::SetProperty, &TableView::GetProperty );
+PropertyRegistration property4( mType, "layout-animation-duration", Toolkit::TableView::PROPERTY_LAYOUT_ANIMATION_DURATION, Property::FLOAT, &TableView::SetProperty, &TableView::GetProperty );
+PropertyRegistration property5( mType, "layout-rows", Toolkit::TableView::PROPERTY_LAYOUT_ROWS, Property::MAP, &TableView::SetProperty, &TableView::GetProperty );
+PropertyRegistration property6( mType, "layout-columns", Toolkit::TableView::PROPERTY_LAYOUT_COLUMNS, Property::MAP, &TableView::SetProperty, &TableView::GetProperty );
+
+} // namespace
+
 Toolkit::TableView TableView::New( unsigned int initialRows, unsigned int initialColumns )
 {
   // Create the implementation, temporarily owned by this handle on stack
@@ -328,14 +359,14 @@ void TableView::InsertRow( unsigned int rowIndex )
 
 void TableView::DeleteRow( unsigned int rowIndex )
 {
-  vector< Actor > ignored;
+  std::vector< Actor > ignored;
   DeleteRow( rowIndex, ignored );
 }
 
-void TableView::DeleteRow( unsigned int rowIndex, vector<Actor>& removed )
+void TableView::DeleteRow( unsigned int rowIndex, std::vector<Actor>& removed )
 {
   RelayoutingLock lock( *this );
-  vector< CellData > lost;
+  std::vector< CellData > lost;
   mCellData.DeleteRow( rowIndex, lost );
   // need to update the cellinfos for the items that moved
   const unsigned int rowCount = mCellData.GetRows();
@@ -415,14 +446,14 @@ void TableView::InsertColumn( unsigned int columnIndex )
 
 void TableView::DeleteColumn( unsigned int columnIndex )
 {
-  vector< Actor > ignored;
+  std::vector< Actor > ignored;
   DeleteColumn( columnIndex, ignored );
 }
 
-void TableView::DeleteColumn( unsigned int columnIndex, vector<Actor>& removed )
+void TableView::DeleteColumn( unsigned int columnIndex, std::vector<Actor>& removed )
 {
   RelayoutingLock lock( *this );
-  vector< CellData > lost;
+  std::vector< CellData > lost;
   mCellData.DeleteColumn( columnIndex, lost );
   // need to update the cellinfos for the items that moved
   const unsigned int rowCount = mCellData.GetRows();
@@ -466,17 +497,17 @@ void TableView::DeleteColumn( unsigned int columnIndex, vector<Actor>& removed )
 
 void TableView::Resize( unsigned int rows, unsigned int columns )
 {
-  vector< Actor > ignored;
+  std::vector< Actor > ignored;
   Resize( rows, columns, ignored );
 }
 
-void TableView::Resize( unsigned int rows, unsigned int columns, vector<Actor>& removed )
+void TableView::Resize( unsigned int rows, unsigned int columns, std::vector<Actor>& removed )
 {
   RelayoutingLock lock( *this );
   unsigned int oldRows = GetRows();
   unsigned int oldColumns = GetColumns();
   // resize data array
-  vector< CellData > lost;
+  std::vector< CellData > lost;
   ResizeContainers( rows, columns, lost );
   // calculate if we lost rows or columns
   unsigned int rowsRemoved = 0;
@@ -517,6 +548,8 @@ void TableView::SetFixedHeight( unsigned int rowIndex, float height )
   DALI_ASSERT_ALWAYS( rowIndex < mFixedHeights.size() );
   // add the fixed height to the array of fixed heights
   mFixedHeights[ rowIndex ] = height;
+  // remove the relative height of the same row
+  mRelativeHeights[ rowIndex ] = 0.f;
   // relayout all cells, no lock needed as nothing added or removed
   RelayoutRequest();
 }
@@ -533,6 +566,8 @@ void TableView::SetRelativeHeight( unsigned int rowIndex, float heightPercentage
   DALI_ASSERT_ALWAYS( rowIndex < mRelativeHeights.size() );
   // add the relative height to the array of relative heights
   mRelativeHeights[ rowIndex ] = heightPercentage;
+  // remove the fixed height of the same row
+  mFixedHeights[ rowIndex ] = 0.f;
   // relayout all cells, no lock needed as nothing added or removed
   RelayoutRequest();
 }
@@ -549,6 +584,8 @@ void TableView::SetFixedWidth( unsigned int columnIndex, float width )
   DALI_ASSERT_ALWAYS( columnIndex < mFixedWidths.size() );
   // add the fixed width to the array of fixed column widths
   mFixedWidths[ columnIndex ] = width;
+  // remove the relative width of the same column
+  mRelativeWidths[ columnIndex ] = 0.f;
   // relayout all cells, no lock needed as nothing added or removed
   RelayoutRequest();
 }
@@ -565,6 +602,8 @@ void TableView::SetRelativeWidth( unsigned int columnIndex, float widthPercentag
   DALI_ASSERT_ALWAYS( columnIndex < mRelativeWidths.size() );
   // add the relative widths to the array of relative widths
   mRelativeWidths[ columnIndex ] = widthPercentage;
+  // remove the fixed width of the same column
+  mFixedWidths[ columnIndex ] = 0.f;
   // relayout all cells, no lock needed as nothing added or removed
   RelayoutRequest();
 }
@@ -738,6 +777,102 @@ unsigned int TableView::GetColumns()
   return mCellData.GetColumns();
 }
 
+void TableView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
+{
+  Toolkit::TableView tableView = Toolkit::TableView::DownCast( Dali::BaseHandle( object ) );
+
+  if( tableView )
+  {
+    TableView& tableViewImpl( GetImpl( tableView ) );
+    switch( index )
+    {
+      case Toolkit::TableView::PROPERTY_ROWS:
+      {
+        if( value.Get<unsigned int>() != tableViewImpl.GetRows() )
+        {
+          tableViewImpl.Resize( value.Get<unsigned int>(), tableViewImpl.GetColumns() );
+        }
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_COLUMNS:
+      {
+        if( value.Get<unsigned int>() != tableViewImpl.GetColumns() )
+        {
+          tableViewImpl.Resize( tableViewImpl.GetRows(), value.Get<unsigned int>() );
+        }
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_CELL_PADDING:
+      {
+        tableViewImpl.SetCellPadding( value.Get<Vector2>() );
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_LAYOUT_ANIMATION_DURATION:
+      {
+        tableViewImpl.SetLayoutAnimationDuration( value.Get<float>() );
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_LAYOUT_ROWS:
+      {
+        SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedHeight, &TableView::SetRelativeHeight, value );
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_LAYOUT_COLUMNS:
+      {
+        SetHeightOrWidthProperty( tableViewImpl, &TableView::SetFixedWidth, &TableView::SetRelativeWidth, value );
+        break;
+      }
+    }
+  }
+}
+
+Property::Value TableView::GetProperty( BaseObject* object, Property::Index index )
+{
+  Property::Value value;
+
+  Toolkit::TableView tableView = Toolkit::TableView::DownCast( Dali::BaseHandle( object ) );
+
+  if( tableView )
+  {
+    TableView& tableViewImpl( GetImpl( tableView ) );
+    switch( index )
+    {
+      case Toolkit::TableView::PROPERTY_ROWS:
+      {
+        value = tableViewImpl.GetRows();
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_COLUMNS:
+      {
+        value = tableViewImpl.GetColumns();
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_CELL_PADDING:
+      {
+        value = tableViewImpl.GetCellPadding();
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_LAYOUT_ANIMATION_DURATION:
+      {
+        value = tableViewImpl.GetLayoutAnimationDuration();
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_LAYOUT_ROWS:
+      {
+        value = tableViewImpl.GetRowHeightsPropertyValue();
+        break;
+      }
+      case Toolkit::TableView::PROPERTY_LAYOUT_COLUMNS:
+      {
+        value = tableViewImpl.GetColumnWidthsPropertyValue();
+        break;
+      }
+    }
+  }
+
+  return value;
+}
+
 void TableView::OnControlChildAdd( Actor& child )
 {
   if( mLayoutingChild )
@@ -745,6 +880,27 @@ void TableView::OnControlChildAdd( Actor& child )
     // we're in the middle of laying out children so no point doing anything here
     return;
   }
+
+  Toolkit::TableView::CellPosition cellPosition;
+  if( child.GetPropertyIndex(Toolkit::TableView::ROW_SPAN_PROPERTY_NAME) != Property::INVALID_INDEX )
+  {
+    cellPosition.rowSpan = static_cast<unsigned int>( child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::ROW_SPAN_PROPERTY_NAME) ).Get<float>() );
+  }
+  if( child.GetPropertyIndex(Toolkit::TableView::COLUMN_SPAN_PROPERTY_NAME) != Property::INVALID_INDEX )
+  {
+    cellPosition.columnSpan = static_cast<unsigned int>( child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::COLUMN_SPAN_PROPERTY_NAME) ).Get<float>() );
+  }
+  if( child.GetPropertyIndex(Toolkit::TableView::CELL_INDICES_PROPERTY_NAME) != Property::INVALID_INDEX )
+  {
+    Vector2 indices = child.GetProperty( child.GetPropertyIndex(Toolkit::TableView::CELL_INDICES_PROPERTY_NAME) ).Get<Vector2 >();
+    cellPosition.rowIndex = static_cast<unsigned int>( indices.x );
+    cellPosition.columnIndex = static_cast<unsigned int>( indices.y );
+
+    AddChild( child, cellPosition );
+    // donot continue
+    return;
+  }
+
   // check if we're already laying out this child somewhere on the table
   // walk through the layout data
   const unsigned int rowCount = mCellData.GetRows();
@@ -814,11 +970,11 @@ void TableView::OnInitialize()
 
 void TableView::ResizeContainers( unsigned int rows, unsigned int columns )
 {
-  vector<CellData> ignored;
+  std::vector<CellData> ignored;
   ResizeContainers( rows, columns, ignored );
 }
 
-void TableView::ResizeContainers( unsigned int rows, unsigned int columns, vector<CellData>& removed )
+void TableView::ResizeContainers( unsigned int rows, unsigned int columns, std::vector<CellData>& removed )
 {
   mCellData.Resize( rows, columns, removed );
   // we dont care if these go smaller, data will be regenerated or is not needed anymore
@@ -829,11 +985,11 @@ void TableView::ResizeContainers( unsigned int rows, unsigned int columns, vecto
   mRelativeWidths.resize( columns );
 }
 
-void TableView::RemoveAndGetLostActors( const vector<CellData>& lost, vector<Actor>& removed,
+void TableView::RemoveAndGetLostActors( const std::vector<CellData>& lost, std::vector<Actor>& removed,
                                         unsigned int rowsRemoved, unsigned int columnsRemoved )
 {
   // iterate through all lost cells
-  vector< CellData >::const_iterator iter = lost.begin();
+  std::vector< CellData >::const_iterator iter = lost.begin();
   for( ; iter != lost.end(); ++iter )
   {
     // if it is a valid actor
@@ -996,6 +1152,80 @@ void TableView::UpdateRelativeSizes( float& fixedHeightsTotal, float& fixedWidth
   }
 }
 
+void TableView::SetHeightOrWidthProperty(TableView& tableViewImpl,
+                                         void(TableView::*funcFixed)(unsigned int, float),
+                                         void(TableView::*funcRelative)(unsigned int, float),
+                                         const Property::Value& value )
+{
+  if( Property::MAP == value.GetType() )
+  {
+    Property::Map map = value.Get<Property::Map>();
+    unsigned int rowIndex(0);
+    for ( unsigned int i = 0, count = map.Count(); i < count; ++i )
+    {
+      Property::Value& item = map.GetValue(i);
+
+      if( std::istringstream(map.GetKey(i)) >> rowIndex  // the key is a number
+          && Property::MAP == item.GetType())
+      {
+        if( item.HasKey( "policy" ) && item.HasKey( "value" ) )
+        {
+          Toolkit::TableView::LayoutPolicy policy = Scripting::GetEnumeration< Toolkit::TableView::LayoutPolicy >( item.GetValue("policy").Get<std::string>(), LAYOUT_POLICY_STRING_TABLE, LAYOUT_POLICY_STRING_TABLE_COUNT );
+          if( policy == Toolkit::TableView::Fixed )
+          {
+            (tableViewImpl.*funcFixed)( rowIndex, item.GetValue("value").Get<float>() );
+          }
+          else if( policy == Toolkit::TableView::Relative )
+          {
+            (tableViewImpl.*funcRelative)( rowIndex, item.GetValue("value").Get<float>() );
+          }
+        }
+      }
+    }
+  }
+}
+
+Property::Value TableView::GetRowHeightsPropertyValue()
+{
+  Property::Map map;
+  GetMapPropertyValue( mFixedHeights, mRelativeHeights, map);
+  return Property::Value(map);
+}
+
+Property::Value TableView::GetColumnWidthsPropertyValue()
+{
+  Property::Map map;
+  GetMapPropertyValue( mFixedWidths, mRelativeWidths, map);
+  return Property::Value(map);
+}
+
+void TableView::GetMapPropertyValue( const std::vector<float>& fixedSize, const std::vector<float>& relativeSize, Property::Map& map )
+{
+  std::string fixedPolicy( Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::Fixed, LAYOUT_POLICY_STRING_TABLE, LAYOUT_POLICY_STRING_TABLE_COUNT ) );
+  std::string relativePolicy( Scripting::GetEnumerationName< Toolkit::TableView::LayoutPolicy >( Toolkit::TableView::Relative, LAYOUT_POLICY_STRING_TABLE, LAYOUT_POLICY_STRING_TABLE_COUNT ) );
+
+  size_t count = fixedSize.size();
+  for( size_t index = 0; index < count; index++ )
+  {
+    if( ! EqualsZero( fixedSize[index] ) )
+    {
+      Property::Map item;
+      item[ "policy" ] = fixedPolicy;
+      item[ "value" ] = fixedSize[index];
+
+      map[ static_cast<std::ostringstream*>( &(std::ostringstream() << index ) )->str() ] = item;
+    }
+    else if( ! EqualsZero( relativeSize[index] ) )
+    {
+      Property::Map item;
+      item[ "policy" ] = relativePolicy;
+      item[ "value" ] = relativeSize[index];
+
+      map[ static_cast<std::ostringstream*>( &(std::ostringstream() << index ) )->str() ] = item;
+    }
+  }
+}
+
 TableView::~TableView()
 {
   // nothing to do