src/Tizen.NUI/src/public/BaseComponents/TableView.cs

   1 /*
   2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 using System;
  19 using System.ComponentModel;
  20 using System.Runtime.InteropServices;
  21 using Tizen.NUI.Binding;
  22
  23 namespace Tizen.NUI.BaseComponents
  24 {
  25
  26     /// <summary>
  27     /// TableView is a layout container for aligning child actors in a grid like layout.<br />
  28     /// TableView constraints the X and the Y position and the width and the height of the child actors.<br />
  29     /// The Z position and depth are left intact so that the 3D model actors can also be laid out
  30     /// in a grid without loosing their depth scaling.<br />
  31     /// </summary>
  32     /// <since_tizen> 3 </since_tizen>
  33     public class TableView : View
  34     {
  35         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  36         [EditorBrowsable(EditorBrowsableState.Never)]
  37         public static readonly BindableProperty RowsProperty = BindableProperty.Create("Rows", typeof(int), typeof(TableView), default(int), propertyChanged: (bindable, oldValue, newValue) =>
  38         {
  39             var tableView = (TableView)bindable;
  40             if (newValue != null)
  41             {
  42                 Tizen.NUI.Object.SetProperty(tableView.swigCPtr, TableView.Property.ROWS, new Tizen.NUI.PropertyValue((int)newValue));
  43             }
  44         },
  45         defaultValueCreator:(bindable) =>
  46         {
  47             var tableView = (TableView)bindable;
  48             int temp = 0;
  49             Tizen.NUI.Object.GetProperty(tableView.swigCPtr, TableView.Property.ROWS).Get(out temp);
  50             return temp;
  51         });
  52         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  53         [EditorBrowsable(EditorBrowsableState.Never)]
  54         public static readonly BindableProperty ColumnsProperty = BindableProperty.Create("Columns", typeof(int), typeof(TableView), default(int), propertyChanged: (bindable, oldValue, newValue) =>
  55         {
  56             var tableView = (TableView)bindable;
  57             if (newValue != null)
  58             {
  59                 Tizen.NUI.Object.SetProperty(tableView.swigCPtr, TableView.Property.COLUMNS, new Tizen.NUI.PropertyValue((int)newValue));
  60             }
  61         },
  62         defaultValueCreator:(bindable) =>
  63         {
  64             var tableView = (TableView)bindable;
  65             int temp = 0;
  66             Tizen.NUI.Object.GetProperty(tableView.swigCPtr, TableView.Property.COLUMNS).Get(out temp);
  67             return temp;
  68         });
  69         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  70         [EditorBrowsable(EditorBrowsableState.Never)]
  71         public static readonly BindableProperty CellPaddingProperty = BindableProperty.Create("CellPadding", typeof(Vector2), typeof(TableView), Vector2.Zero, propertyChanged: (bindable, oldValue, newValue) =>
  72         {
  73             var tableView = (TableView)bindable;
  74             if (newValue != null)
  75             {
  76                 Tizen.NUI.Object.SetProperty(tableView.swigCPtr, TableView.Property.CELL_PADDING, new Tizen.NUI.PropertyValue((Vector2)newValue));
  77             }
  78         },
  79         defaultValueCreator:(bindable) =>
  80         {
  81             var tableView = (TableView)bindable;
  82             Vector2 temp = new Vector2(0.0f, 0.0f);
  83             Tizen.NUI.Object.GetProperty(tableView.swigCPtr, TableView.Property.CELL_PADDING).Get(temp);
  84             return temp;
  85         });
  86         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  87         [EditorBrowsable(EditorBrowsableState.Never)]
  88         public static readonly BindableProperty LayoutRowsProperty = BindableProperty.Create("LayoutRows", typeof(PropertyMap), typeof(TableView), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
  89         {
  90             var tableView = (TableView)bindable;
  91             if (newValue != null)
  92             {
  93                 Tizen.NUI.Object.SetProperty(tableView.swigCPtr, TableView.Property.LAYOUT_ROWS, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
  94             }
  95         },
  96         defaultValueCreator:(bindable) =>
  97         {
  98             var tableView = (TableView)bindable;
  99             PropertyMap temp = new PropertyMap();
 100             Tizen.NUI.Object.GetProperty(tableView.swigCPtr, TableView.Property.LAYOUT_ROWS).Get(temp);
 101             return temp;
 102         });
 103         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 104         [EditorBrowsable(EditorBrowsableState.Never)]
 105         public static readonly BindableProperty LayoutColumnsProperty = BindableProperty.Create("LayoutColumns", typeof(PropertyMap), typeof(TableView), new PropertyMap(), propertyChanged: (bindable, oldValue, newValue) =>
 106         {
 107             var tableView = (TableView)bindable;
 108             if (newValue != null)
 109             {
 110                 Tizen.NUI.Object.SetProperty(tableView.swigCPtr, TableView.Property.LAYOUT_COLUMNS, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 111             }
 112         },
 113         defaultValueCreator:(bindable) =>
 114         {
 115             var tableView = (TableView)bindable;
 116             PropertyMap temp = new PropertyMap();
 117             Tizen.NUI.Object.GetProperty(tableView.swigCPtr, TableView.Property.LAYOUT_COLUMNS).Get(temp);
 118             return temp;
 119         });
 120
 121
 122         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 123
 124         internal TableView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.TableView_SWIGUpcast(cPtr), cMemoryOwn)
 125         {
 126             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 127         }
 128
 129         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TableView obj)
 130         {
 131             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 132         }
 133
 134         /// <summary>
 135         /// Dispose
 136         /// </summary>
 137         /// <param name="type">The dispose type</param>
 138         /// <since_tizen> 3 </since_tizen>
 139         protected override void Dispose(DisposeTypes type)
 140         {
 141             if (disposed)
 142             {
 143                 return;
 144             }
 145
 146             if (type == DisposeTypes.Explicit)
 147             {
 148                 //Called by User
 149                 //Release your own managed resources here.
 150                 //You should release all of your own disposable objects here.
 151             }
 152
 153             //Release your own unmanaged resources here.
 154             //You should not access any managed member here except static instance.
 155             //because the execution order of Finalizes is non-deterministic.
 156
 157             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 158             {
 159                 if (swigCMemOwn)
 160                 {
 161                     swigCMemOwn = false;
 162                     NDalicPINVOKE.delete_TableView(swigCPtr);
 163                 }
 164                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 165             }
 166
 167             base.Dispose(type);
 168         }
 169
 170
 171         internal new class Property
 172         {
 173             internal static readonly int ROWS = NDalicPINVOKE.TableView_Property_ROWS_get();
 174             internal static readonly int COLUMNS = NDalicPINVOKE.TableView_Property_COLUMNS_get();
 175             internal static readonly int CELL_PADDING = NDalicPINVOKE.TableView_Property_CELL_PADDING_get();
 176             internal static readonly int LAYOUT_ROWS = NDalicPINVOKE.TableView_Property_LAYOUT_ROWS_get();
 177             internal static readonly int LAYOUT_COLUMNS = NDalicPINVOKE.TableView_Property_LAYOUT_COLUMNS_get();
 178         }
 179
 180         internal class ChildProperty
 181         {
 182             internal static readonly int CELL_INDEX = NDalicPINVOKE.TableView_ChildProperty_CELL_INDEX_get();
 183             internal static readonly int ROW_SPAN = NDalicPINVOKE.TableView_ChildProperty_ROW_SPAN_get();
 184             internal static readonly int COLUMN_SPAN = NDalicPINVOKE.TableView_ChildProperty_COLUMN_SPAN_get();
 185             internal static readonly int CELL_HORIZONTAL_ALIGNMENT = NDalicPINVOKE.TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get();
 186             internal static readonly int CELL_VERTICAL_ALIGNMENT = NDalicPINVOKE.TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get();
 187         }
 188
 189         /// <summary>
 190         /// Class to specify the layout position for the child view.
 191         /// </summary>
 192         /// <since_tizen> 3 </since_tizen>
 193         public class CellPosition : global::System.IDisposable
 194         {
 195             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 196             /// <summary>
 197             /// swigCMemOwn
 198             /// </summary>
 199             /// <since_tizen> 3 </since_tizen>
 200             protected bool swigCMemOwn;
 201
 202             internal CellPosition(global::System.IntPtr cPtr, bool cMemoryOwn)
 203             {
 204                 swigCMemOwn = cMemoryOwn;
 205                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 206             }
 207
 208             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CellPosition obj)
 209             {
 210                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 211             }
 212
 213             //A Flag to check who called Dispose(). (By User or DisposeQueue)
 214             private bool isDisposeQueued = false;
 215             /// <summary>
 216             /// A Flat to check if it is already disposed.
 217             /// </summary>
 218             /// <since_tizen> 3 </since_tizen>
 219             protected bool disposed = false;
 220
 221             /// <summary>
 222             /// Dispose.
 223             /// </summary>
 224             /// <since_tizen> 3 </since_tizen>
 225             ~CellPosition()
 226             {
 227                 if (!isDisposeQueued)
 228                 {
 229                     isDisposeQueued = true;
 230                     DisposeQueue.Instance.Add(this);
 231                 }
 232             }
 233
 234             /// <summary>
 235             /// Dispose.
 236             /// </summary>
 237             /// <since_tizen> 3 </since_tizen>
 238             public void Dispose()
 239             {
 240                 //Throw excpetion if Dispose() is called in separate thread.
 241                 if (!Window.IsInstalled())
 242                 {
 243                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 244                 }
 245
 246                 if (isDisposeQueued)
 247                 {
 248                     Dispose(DisposeTypes.Implicit);
 249                 }
 250                 else
 251                 {
 252                     Dispose(DisposeTypes.Explicit);
 253                     System.GC.SuppressFinalize(this);
 254                 }
 255             }
 256
 257             /// <summary>
 258             /// Dispose.
 259             /// </summary>
 260             /// <param name="type">DisposeTypes</param>
 261             /// <since_tizen> 3 </since_tizen>
 262             protected virtual void Dispose(DisposeTypes type)
 263             {
 264                 if (disposed)
 265                 {
 266                     return;
 267                 }
 268
 269                 if (type == DisposeTypes.Explicit)
 270                 {
 271                     //Called by User
 272                     //Release your own managed resources here.
 273                     //You should release all of your own disposable objects here.
 274                 }
 275
 276                 //Release your own unmanaged resources here.
 277                 //You should not access any managed member here except static instance.
 278                 //because the execution order of Finalizes is non-deterministic.
 279
 280                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
 281                 {
 282                     if (swigCMemOwn)
 283                     {
 284                         swigCMemOwn = false;
 285                         NDalicPINVOKE.delete_TableView_CellPosition(swigCPtr);
 286                     }
 287                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 288                 }
 289                 disposed = true;
 290             }
 291
 292             /// <summary>
 293             /// The constructor.
 294             /// </summary>
 295             /// <param name="rowIndex">The row index initialized.</param>
 296             /// <param name="columnIndex">The column index initialized.</param>
 297             /// <param name="rowSpan">The row span initialized.</param>
 298             /// <param name="columnSpan">The column span initialized.</param>
 299             /// <since_tizen> 3 </since_tizen>
 300             public CellPosition(uint rowIndex, uint columnIndex, uint rowSpan, uint columnSpan) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_0(rowIndex, columnIndex, rowSpan, columnSpan), true)
 301             {
 302                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 303             }
 304
 305             /// <summary>
 306             /// The constructor to initialize values to defaults for convenience.
 307             /// </summary>
 308             /// <param name="rowIndex">The row index initialized.</param>
 309             /// <param name="columnIndex">The column index initialized.</param>
 310             /// <param name="rowSpan">The row span initialized.</param>
 311             /// <since_tizen> 3 </since_tizen>
 312             public CellPosition(uint rowIndex, uint columnIndex, uint rowSpan) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_1(rowIndex, columnIndex, rowSpan), true)
 313             {
 314                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 315             }
 316
 317             /// <summary>
 318             /// The constructor to initialize values to defaults for convenience.
 319             /// </summary>
 320             /// <param name="rowIndex">The row index initialized.</param>
 321             /// <param name="columnIndex">The column index initialized.</param>
 322             /// <since_tizen> 3 </since_tizen>
 323             public CellPosition(uint rowIndex, uint columnIndex) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_2(rowIndex, columnIndex), true)
 324             {
 325                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 326             }
 327
 328             /// <summary>
 329             /// The constructor to initialize values to default for convenience.
 330             /// </summary>
 331             /// <param name="rowIndex">The row index initialized.</param>
 332             /// <since_tizen> 3 </since_tizen>
 333             public CellPosition(uint rowIndex) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_3(rowIndex), true)
 334             {
 335                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 336             }
 337
 338             /// <summary>
 339             /// The default constructor.
 340             /// </summary>
 341             /// <since_tizen> 3 </since_tizen>
 342             public CellPosition() : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_4(), true)
 343             {
 344                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 345             }
 346
 347             /// <summary>
 348             /// The index of a row.
 349             /// </summary>
 350             /// <since_tizen> 3 </since_tizen>
 351             [Obsolete("Please do not use! This will be deprecated! Please use RowIndex instead!")]
 352             [EditorBrowsable(EditorBrowsableState.Never)]
 353             public uint rowIndex
 354             {
 355                 set
 356                 {
 357                     NDalicPINVOKE.TableView_CellPosition_rowIndex_set(swigCPtr, value);
 358                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 359                 }
 360                 get
 361                 {
 362                     uint ret = NDalicPINVOKE.TableView_CellPosition_rowIndex_get(swigCPtr);
 363                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 364                     return ret;
 365                 }
 366             }
 367
 368             /// <summary>
 369             /// The index or position of a row.
 370             /// </summary>
 371             /// <since_tizen> 5 </since_tizen>
 372             public uint RowIndex
 373             {
 374                 get
 375                 {
 376                     uint ret = NDalicPINVOKE.TableView_CellPosition_rowIndex_get(swigCPtr);
 377                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 378                     return ret;
 379                 }
 380             }
 381
 382
 383             /// <summary>
 384             /// The index of a column.
 385             /// </summary>
 386             /// <since_tizen> 3 </since_tizen>
 387             [Obsolete("Please do not use! This will be deprecated! Please use ColumnIndex instead!")]
 388             [EditorBrowsable(EditorBrowsableState.Never)]
 389             public uint columnIndex
 390             {
 391                 set
 392                 {
 393                     NDalicPINVOKE.TableView_CellPosition_columnIndex_set(swigCPtr, value);
 394                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 395                 }
 396                 get
 397                 {
 398                     uint ret = NDalicPINVOKE.TableView_CellPosition_columnIndex_get(swigCPtr);
 399                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 400                     return ret;
 401                 }
 402             }
 403
 404             /// <summary>
 405             /// The index or position of a column.
 406             /// </summary>
 407             /// <since_tizen> 5 </since_tizen>
 408             public uint ColumnIndex
 409             {
 410                 get
 411                 {
 412                     uint ret = NDalicPINVOKE.TableView_CellPosition_columnIndex_get(swigCPtr);
 413                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 414                     return ret;
 415                 }
 416             }
 417
 418             /// <summary>
 419             /// The span of a row.
 420             /// </summary>
 421             /// <since_tizen> 3 </since_tizen>
 422             [Obsolete("Please do not use! This will be deprecated! Please use RowSpan instead!")]
 423             [EditorBrowsable(EditorBrowsableState.Never)]
 424             public uint rowSpan
 425             {
 426                 set
 427                 {
 428                     NDalicPINVOKE.TableView_CellPosition_rowSpan_set(swigCPtr, value);
 429                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 430                 }
 431                 get
 432                 {
 433                     uint ret = NDalicPINVOKE.TableView_CellPosition_rowSpan_get(swigCPtr);
 434                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 435                     return ret;
 436                 }
 437             }
 438
 439             /// <summary>
 440             /// The span of a row.
 441             /// </summary>
 442             /// <since_tizen> 5 </since_tizen>
 443             public uint RowSpan
 444             {
 445                 get
 446                 {
 447                     uint ret = NDalicPINVOKE.TableView_CellPosition_rowSpan_get(swigCPtr);
 448                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 449                     return ret;
 450                 }
 451             }
 452
 453             /// <summary>
 454             /// The span of a column.
 455             /// </summary>
 456             /// <since_tizen> 3 </since_tizen>
 457             [Obsolete("Please do not use! This will be deprecated! Please use ColumnSpan instead!")]
 458             [EditorBrowsable(EditorBrowsableState.Never)]
 459             public uint columnSpan
 460             {
 461                 set
 462                 {
 463                     NDalicPINVOKE.TableView_CellPosition_columnSpan_set(swigCPtr, value);
 464                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 465                 }
 466                 get
 467                 {
 468                     uint ret = NDalicPINVOKE.TableView_CellPosition_columnSpan_get(swigCPtr);
 469                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470                     return ret;
 471                 }
 472             }
 473
 474             /// <summary>
 475             /// The span of a column.
 476             /// </summary>
 477             /// <since_tizen> 5 </since_tizen>
 478             public uint ColumnSpan
 479             {
 480                 get
 481                 {
 482                     uint ret = NDalicPINVOKE.TableView_CellPosition_columnSpan_get(swigCPtr);
 483                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 484                     return ret;
 485                 }
 486             }
 487
 488
 489         }
 490
 491         /// <summary>
 492         /// Creates the default TableView view.
 493         /// </summary>
 494         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 495         [EditorBrowsable(EditorBrowsableState.Never)]
 496         public TableView() : this(NDalicPINVOKE.TableView_New(1, 1), true)
 497         {
 498             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 499         }
 500
 501         /// <summary>
 502         /// Creates the TableView view.
 503         /// </summary>
 504         /// <param name="initialRows">Initial rows for the table.</param>
 505         /// <param name="initialColumns">Initial columns for the table.</param>
 506         /// <since_tizen> 3 </since_tizen>
 507         public TableView(uint initialRows, uint initialColumns) : this(NDalicPINVOKE.TableView_New(initialRows, initialColumns), true)
 508         {
 509             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 510
 511         }
 512
 513         /// <summary>
 514         /// The Copy constructor. Creates another handle that points to the same real object.
 515         /// </summary>
 516         /// <param name="handle">Handle to copy from.</param>
 517         /// <since_tizen> 3 </since_tizen>
 518         public TableView(TableView handle) : this(NDalicPINVOKE.new_TableView__SWIG_1(TableView.getCPtr(handle)), true)
 519         {
 520             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 521         }
 522
 523         /// <summary>
 524         /// Adds a child to the table.<br />
 525         /// If the row or column index is outside the table, the table gets resized bigger.<br />
 526         /// </summary>
 527         /// <param name="child">The child to add.</param>
 528         /// <param name="position">The position for the child.</param>
 529         /// <returns>True if the addition succeeded, and false if the cell is already occupied.</returns>
 530         /// <since_tizen> 3 </since_tizen>
 531         public bool AddChild(View child, TableView.CellPosition position)
 532         {
 533             bool ret = NDalicPINVOKE.TableView_AddChild(swigCPtr, View.getCPtr(child), TableView.CellPosition.getCPtr(position));
 534             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 535             return ret;
 536         }
 537
 538         /// <summary>
 539         /// Returns a child from the given layout position.
 540         /// </summary>
 541         /// <param name="position">The position in the table.</param>
 542         /// <returns>Child that was in the cell or an uninitialized handle.</returns>
 543         /// <since_tizen> 3 </since_tizen>
 544         public View GetChildAt(TableView.CellPosition position)
 545         {
 546             //to fix memory leak issue, match the handle count with native side.
 547             IntPtr cPtr = NDalicPINVOKE.TableView_GetChildAt(swigCPtr, TableView.CellPosition.getCPtr(position));
 548             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 549             View ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as View;
 550             NDalicPINVOKE.delete_BaseHandle(CPtr);
 551             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 552
 553             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 554             return ret;
 555         }
 556
 557         /// <summary>
 558         /// Removes a child from the given layout position.
 559         /// </summary>
 560         /// <param name="position">The position for the child to remove.</param>
 561         /// <returns>Child that was removed or an uninitialized handle.</returns>
 562         /// <since_tizen> 3 </since_tizen>
 563         public View RemoveChildAt(TableView.CellPosition position)
 564         {
 565             //to fix memory leak issue, match the handle count with native side.
 566             IntPtr cPtr = NDalicPINVOKE.TableView_RemoveChildAt(swigCPtr, TableView.CellPosition.getCPtr(position));
 567             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 568             View ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as View;
 569             NDalicPINVOKE.delete_BaseHandle(CPtr);
 570             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 571
 572             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 573             return ret;
 574         }
 575
 576         /// <summary>
 577         /// Finds the child's layout position.
 578         /// </summary>
 579         /// <param name="child">The child to search for.</param>
 580         /// <param name="position">The position for the child.</param>
 581         /// <returns>True if the child was included in this TableView.</returns>
 582         /// <since_tizen> 3 </since_tizen>
 583         public bool FindChildPosition(View child, TableView.CellPosition position)
 584         {
 585             bool ret = NDalicPINVOKE.TableView_FindChildPosition(swigCPtr, View.getCPtr(child), TableView.CellPosition.getCPtr(position));
 586             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 587             return ret;
 588         }
 589
 590         /// <summary>
 591         /// Inserts a new row to the given index.
 592         /// </summary>
 593         /// <param name="rowIndex">The rowIndex of the new row.</param>
 594         /// <since_tizen> 3 </since_tizen>
 595         public void InsertRow(uint rowIndex)
 596         {
 597             NDalicPINVOKE.TableView_InsertRow(swigCPtr, rowIndex);
 598             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 599         }
 600
 601         /// <summary>
 602         /// Deletes a row from the given index.<br />
 603         /// Removed elements are deleted.<br />
 604         /// </summary>
 605         /// <param name="rowIndex">The rowIndex of the row to delete.</param>
 606         /// <since_tizen> 3 </since_tizen>
 607         public void DeleteRow(uint rowIndex)
 608         {
 609             NDalicPINVOKE.TableView_DeleteRow__SWIG_0(swigCPtr, rowIndex);
 610             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 611         }
 612
 613         /// <summary>
 614         /// Inserts a new column to the given index.
 615         /// </summary>
 616         /// <param name="columnIndex">The columnIndex of the new column.</param>
 617         /// <since_tizen> 3 </since_tizen>
 618         public void InsertColumn(uint columnIndex)
 619         {
 620             NDalicPINVOKE.TableView_InsertColumn(swigCPtr, columnIndex);
 621             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 622         }
 623
 624         /// <summary>
 625         /// Deletes a column from the given index.<br />
 626         /// Removed elements are deleted.<br />
 627         /// </summary>
 628         /// <param name="columnIndex">The columnIndex of the column to delete.</param>
 629         /// <since_tizen> 3 </since_tizen>
 630         public void DeleteColumn(uint columnIndex)
 631         {
 632             NDalicPINVOKE.TableView_DeleteColumn__SWIG_0(swigCPtr, columnIndex);
 633             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 634         }
 635
 636         /// <summary>
 637         /// Resizes the TableView.
 638         /// </summary>
 639         /// <param name="rows">The rows for the table.</param>
 640         /// <param name="columns">The columns for the table.</param>
 641         /// <since_tizen> 3 </since_tizen>
 642         public void Resize(uint rows, uint columns)
 643         {
 644             NDalicPINVOKE.TableView_Resize__SWIG_0(swigCPtr, rows, columns);
 645             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 646         }
 647
 648         /// <summary>
 649         /// Sets the horizontal and the vertical padding between cells.
 650         /// </summary>
 651         /// <param name="padding">Width and height.</param>
 652         /// <since_tizen> 3 </since_tizen>
 653         public void SetCellPadding(Size2D padding)
 654         {
 655             NDalicPINVOKE.TableView_SetCellPadding(swigCPtr, Size2D.getCPtr(padding));
 656             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 657         }
 658
 659         /// <summary>
 660         /// Gets the current padding as width and height.
 661         /// </summary>
 662         /// <returns>The current padding as width and height.</returns>
 663         /// <since_tizen> 3 </since_tizen>
 664         public Vector2 GetCellPadding()
 665         {
 666             Vector2 ret = new Vector2(NDalicPINVOKE.TableView_GetCellPadding(swigCPtr), true);
 667             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 668             return ret;
 669         }
 670
 671         /// <summary>
 672         /// Specifies this row as fitting its height to its children.
 673         /// </summary>
 674         /// <param name="rowIndex">The row to set.</param>
 675         /// <since_tizen> 3 </since_tizen>
 676         public void SetFitHeight(uint rowIndex)
 677         {
 678             NDalicPINVOKE.TableView_SetFitHeight(swigCPtr, rowIndex);
 679             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 680         }
 681
 682         /// <summary>
 683         /// Checks if the row is a fit row.
 684         /// </summary>
 685         /// <param name="rowIndex">The row to check.</param>
 686         /// <returns>True if the row is fit.</returns>
 687         /// <since_tizen> 3 </since_tizen>
 688         public bool IsFitHeight(uint rowIndex)
 689         {
 690             bool ret = NDalicPINVOKE.TableView_IsFitHeight(swigCPtr, rowIndex);
 691             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 692             return ret;
 693         }
 694
 695         /// <summary>
 696         /// Specifies this column as fitting its width to its children.
 697         /// </summary>
 698         /// <param name="columnIndex">The column to set.</param>
 699         /// <since_tizen> 3 </since_tizen>
 700         public void SetFitWidth(uint columnIndex)
 701         {
 702             NDalicPINVOKE.TableView_SetFitWidth(swigCPtr, columnIndex);
 703             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 704         }
 705
 706         /// <summary>
 707         /// Checks if the column is a fit column.
 708         /// </summary>
 709         /// <param name="columnIndex">The column to check.</param>
 710         /// <returns>True if the column is fit.</returns>
 711         /// <since_tizen> 3 </since_tizen>
 712         public bool IsFitWidth(uint columnIndex)
 713         {
 714             bool ret = NDalicPINVOKE.TableView_IsFitWidth(swigCPtr, columnIndex);
 715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 716             return ret;
 717         }
 718
 719         /// <summary>
 720         /// Sets a row to have a fixed height.<br />
 721         /// Setting a fixed height of 0 has no effect.<br />
 722         /// </summary>
 723         /// <param name="rowIndex">The rowIndex for row with a fixed height.</param>
 724         /// <param name="height">The height in world coordinate units.</param>
 725         /// <since_tizen> 3 </since_tizen>
 726         public void SetFixedHeight(uint rowIndex, float height)
 727         {
 728             NDalicPINVOKE.TableView_SetFixedHeight(swigCPtr, rowIndex, height);
 729             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 730         }
 731
 732         /// <summary>
 733         /// Gets a row's fixed height.
 734         /// </summary>
 735         /// <param name="rowIndex">The row index with a fixed height.</param>
 736         /// <returns>height The height in world coordinate units.</returns>
 737         /// <since_tizen> 3 </since_tizen>
 738         public float GetFixedHeight(uint rowIndex)
 739         {
 740             float ret = NDalicPINVOKE.TableView_GetFixedHeight(swigCPtr, rowIndex);
 741             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 742             return ret;
 743         }
 744
 745         /// <summary>
 746         /// Sets a row to have a relative height. Relative height means percentage of
 747         /// the remainder of the table height after subtracting padding and fixed height rows.<br />
 748         /// Setting a relative height of 0 has no effect.<br />
 749         /// </summary>
 750         /// <param name="rowIndex">The rowIndex for row with a relative height.</param>
 751         /// <param name="heightPercentage">The height percentage between 0.0f and 1.0f.</param>
 752         /// <since_tizen> 3 </since_tizen>
 753         public void SetRelativeHeight(uint rowIndex, float heightPercentage)
 754         {
 755             NDalicPINVOKE.TableView_SetRelativeHeight(swigCPtr, rowIndex, heightPercentage);
 756             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 757         }
 758
 759         /// <summary>
 760         /// Gets a row's relative height.
 761         /// </summary>
 762         /// <param name="rowIndex">The row index with a relative height.</param>
 763         /// <returns>Height in percentage units, between 0.0f and 1.0f.</returns>
 764         /// <since_tizen> 3 </since_tizen>
 765         public float GetRelativeHeight(uint rowIndex)
 766         {
 767             float ret = NDalicPINVOKE.TableView_GetRelativeHeight(swigCPtr, rowIndex);
 768             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 769             return ret;
 770         }
 771
 772         /// <summary>
 773         /// Sets a column to have a fixed width.<br />
 774         /// Setting a fixed width of 0 has no effect.<br />
 775         /// </summary>
 776         /// <param name="columnIndex">The columnIndex for column with a fixed width.</param>
 777         /// <param name="width">The width in world coordinate units.</param>
 778         /// <since_tizen> 3 </since_tizen>
 779         public void SetFixedWidth(uint columnIndex, float width)
 780         {
 781             NDalicPINVOKE.TableView_SetFixedWidth(swigCPtr, columnIndex, width);
 782             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 783         }
 784
 785         /// <summary>
 786         /// Gets a column's fixed width.
 787         /// </summary>
 788         /// <param name="columnIndex">The column index with a fixed width.</param>
 789         /// <returns>Width in world coordinate units.</returns>
 790         /// <since_tizen> 3 </since_tizen>
 791         public float GetFixedWidth(uint columnIndex)
 792         {
 793             float ret = NDalicPINVOKE.TableView_GetFixedWidth(swigCPtr, columnIndex);
 794             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 795             return ret;
 796         }
 797
 798         /// <summary>
 799         /// Sets a column to have a relative width. Relative width means percentage of
 800         /// the remainder of the table width after subtracting padding and fixed width columns.<br />
 801         /// Setting a relative width of 0 has no effect.<br />
 802         /// </summary>
 803         /// <param name="columnIndex">The columnIndex for column with a fixed width.</param>
 804         /// <param name="widthPercentage">The widthPercentage between 0.0f and 1.0f.</param>
 805         /// <since_tizen> 3 </since_tizen>
 806         public void SetRelativeWidth(uint columnIndex, float widthPercentage)
 807         {
 808             NDalicPINVOKE.TableView_SetRelativeWidth(swigCPtr, columnIndex, widthPercentage);
 809             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 810         }
 811
 812         /// <summary>
 813         /// Gets a column's relative width.
 814         /// </summary>
 815         /// <param name="columnIndex">The column index with a relative width.</param>
 816         /// <returns>Width in percentage units, between 0.0f and 1.0f.</returns>
 817         /// <since_tizen> 3 </since_tizen>
 818         public float GetRelativeWidth(uint columnIndex)
 819         {
 820             float ret = NDalicPINVOKE.TableView_GetRelativeWidth(swigCPtr, columnIndex);
 821             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 822             return ret;
 823         }
 824
 825         /// <summary>
 826         /// Sets the alignment on a cell.<br />
 827         /// Cells without calling this function have the default values of left and top respectively.<br />
 828         /// </summary>
 829         /// <param name="position">The cell to set alignment on.</param>
 830         /// <param name="horizontal">The horizontal alignment.</param>
 831         /// <param name="vertical">The vertical alignment.</param>
 832         /// <since_tizen> 3 </since_tizen>
 833         public void SetCellAlignment(TableView.CellPosition position, HorizontalAlignmentType horizontal, VerticalAlignmentType vertical)
 834         {
 835             NDalicPINVOKE.TableView_SetCellAlignment(swigCPtr, TableView.CellPosition.getCPtr(position), (int)horizontal, (int)vertical);
 836             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 837         }
 838
 839         /// <summary>
 840         /// Enumeration for describing how the size of a row or column has been set.
 841         /// </summary>
 842         /// <since_tizen> 3 </since_tizen>
 843         public enum LayoutPolicy
 844         {
 845             /// <summary>
 846             /// Fixed with the given value.
 847             /// </summary>
 848             /// <since_tizen> 3 </since_tizen>
 849             Fixed,
 850             /// <summary>
 851             /// Calculated as percentage of the remainder after subtracting Padding and Fixed height/width.
 852             /// </summary>
 853             /// <since_tizen> 3 </since_tizen>
 854             Relative,
 855             /// <summary>
 856             ///  Default policy, get the remainder of the 100% (after subtracting Fixed, Fit and Relative height/ width) divided evenly between 'fill' rows/columns.
 857             /// </summary>
 858             /// <since_tizen> 3 </since_tizen>
 859             Fill,
 860             /// <summary>
 861             /// Fit around its children.
 862             /// </summary>
 863             /// <since_tizen> 3 </since_tizen>
 864             Fit
 865         }
 866
 867         /// <summary>
 868         /// The amount of rows in the table.
 869         /// </summary>
 870         /// <since_tizen> 3 </since_tizen>
 871         public int Rows
 872         {
 873             get
 874             {
 875                 return (int)GetValue(RowsProperty);
 876             }
 877             set
 878             {
 879                 SetValue(RowsProperty, value);
 880                 NotifyPropertyChanged();
 881             }
 882         }
 883         /// <summary>
 884         /// The amount of columns in the table.
 885         /// </summary>
 886         /// <since_tizen> 3 </since_tizen>
 887         public int Columns
 888         {
 889             get
 890             {
 891                 return (int)GetValue(ColumnsProperty);
 892             }
 893             set
 894             {
 895                 SetValue(ColumnsProperty, value);
 896                 NotifyPropertyChanged();
 897             }
 898         }
 899         /// <summary>
 900         /// Padding between cells.
 901         /// </summary>
 902         /// <since_tizen> 3 </since_tizen>
 903         public Vector2 CellPadding
 904         {
 905             get
 906             {
 907                 return (Vector2)GetValue(CellPaddingProperty);
 908             }
 909             set
 910             {
 911                 SetValue(CellPaddingProperty, value);
 912                 NotifyPropertyChanged();
 913             }
 914         }
 915
 916         /// <summary>
 917         /// The number of layout rows.
 918         /// </summary>
 919         /// <since_tizen> 3 </since_tizen>
 920         public PropertyMap LayoutRows
 921         {
 922             get
 923             {
 924                 return (PropertyMap)GetValue(LayoutRowsProperty);
 925             }
 926             set
 927             {
 928                 SetValue(LayoutRowsProperty, value);
 929                 NotifyPropertyChanged();
 930             }
 931         }
 932
 933         /// <summary>
 934         /// The number of layout columns.
 935         /// </summary>
 936         /// <since_tizen> 3 </since_tizen>
 937         public PropertyMap LayoutColumns
 938         {
 939             get
 940             {
 941                 return (PropertyMap)GetValue(LayoutColumnsProperty);
 942             }
 943             set
 944             {
 945                 SetValue(LayoutColumnsProperty, value);
 946                 NotifyPropertyChanged();
 947             }
 948         }
 949
 950     }
 951 }