src/Tizen.NUI/src/public/Property.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
  21 namespace Tizen.NUI
  22 {
  23
  24     internal class Property : global::System.IDisposable
  25     {
  26         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  27         /// <summary>
  28         /// swigCMemOwn
  29         /// </summary>
  30         /// <since_tizen> 3 </since_tizen>
  31         protected bool swigCMemOwn;
  32
  33         internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
  34         {
  35             swigCMemOwn = cMemoryOwn;
  36             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  37         }
  38
  39         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
  40         {
  41             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  42         }
  43
  44         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  45         private bool isDisposeQueued = false;
  46         /// <summary>
  47         /// <since_tizen> 3 </since_tizen>
  48         /// A Flat to check if it is already disposed.
  49         /// </summary>
  50         protected bool disposed = false;
  51
  52         ~Property()
  53         {
  54             if(!isDisposeQueued)
  55             {
  56                 isDisposeQueued = true;
  57                 DisposeQueue.Instance.Add(this);
  58             }
  59         }
  60
  61         public void Dispose()
  62         {
  63             //Throw excpetion if Dispose() is called in separate thread.
  64             if (!Window.IsInstalled())
  65             {
  66                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  67             }
  68
  69             if (isDisposeQueued)
  70             {
  71                 Dispose(DisposeTypes.Implicit);
  72             }
  73             else
  74             {
  75                 Dispose(DisposeTypes.Explicit);
  76                 System.GC.SuppressFinalize(this);
  77             }
  78         }
  79
  80         protected virtual void Dispose(DisposeTypes type)
  81         {
  82             if (disposed)
  83             {
  84                 return;
  85             }
  86
  87             if(type == DisposeTypes.Explicit)
  88             {
  89                 //Called by User
  90                 //Release your own managed resources here.
  91                 //You should release all of your own disposable objects here.
  92             }
  93
  94             //Release your own unmanaged resources here.
  95             //You should not access any managed member here except static instance.
  96             //because the execution order of Finalizes is non-deterministic.
  97
  98             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  99             {
 100                 if (swigCMemOwn)
 101                 {
 102                     swigCMemOwn = false;
 103                     NDalicPINVOKE.delete_Property(swigCPtr);
 104                 }
 105                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 106             }
 107             disposed = true;
 108         }
 109
 110
 111         internal static int INVALID_INDEX
 112         {
 113             get
 114             {
 115                 int ret = NDalicPINVOKE.Property_INVALID_INDEX_get();
 116                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 117                 return ret;
 118             }
 119         }
 120
 121         internal static int INVALID_KEY
 122         {
 123             get
 124             {
 125                 int ret = NDalicPINVOKE.Property_INVALID_KEY_get();
 126                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 127                 return ret;
 128             }
 129         }
 130
 131         internal static int INVALID_COMPONENT_INDEX
 132         {
 133             get
 134             {
 135                 int ret = NDalicPINVOKE.Property_INVALID_COMPONENT_INDEX_get();
 136                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 137                 return ret;
 138             }
 139         }
 140
 141         /// <summary>
 142         /// This constructor creates a property instance.
 143         /// </summary>
 144         /// <param name="arg0">A valid handle to the target object.</param>
 145         /// <param name="propertyIndex">The index of a property.</param>
 146         /// <since_tizen> 3 </since_tizen>
 147         public Property(Animatable arg0, int propertyIndex) : this(NDalicPINVOKE.new_Property__SWIG_0(Animatable.getCPtr(arg0), propertyIndex), true)
 148         {
 149             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 150         }
 151
 152         /// <summary>
 153         /// This constructor creates a property instance.
 154         /// </summary>
 155         /// <param name="arg0">A valid handle to the target object.</param>
 156         /// <param name="propertyIndex">The index of a property.</param>
 157         /// <param name="componentIndex">Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for the main property (default is -1).</param>
 158         /// <since_tizen> 3 </since_tizen>
 159         public Property(Animatable arg0, int propertyIndex, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_1(Animatable.getCPtr(arg0), propertyIndex, componentIndex), true)
 160         {
 161             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 162         }
 163
 164         /// <summary>
 165         /// This constructor creates a property instance.<br />
 166         /// This performs a property index query and is therefore slower than constructing a property directly with the index.<br />
 167         /// </summary>
 168         /// <param name="arg0">A valid handle to the target object.</param>
 169         /// <param name="propertyName">The property name.</param>
 170         /// <since_tizen> 3 </since_tizen>
 171         public Property(Animatable arg0, string propertyName) : this(NDalicPINVOKE.new_Property__SWIG_2(Animatable.getCPtr(arg0), propertyName), true)
 172         {
 173             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 174         }
 175
 176         /// <summary>
 177         /// This constructor creates a property instance.<br />
 178         /// This performs a property index query and is therefore slower than constructing a property directly with the index.<br />
 179         /// </summary>
 180         /// <param name="arg0">A valid handle to the target object.</param>
 181         /// <param name="propertyName">The property name.</param>
 182         /// <param name="componentIndex">Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for main property (default is -1).</param>
 183         /// <since_tizen> 3 </since_tizen>
 184         public Property(Animatable arg0, string propertyName, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_3(Animatable.getCPtr(arg0), propertyName, componentIndex), true)
 185         {
 186             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 187         }
 188
 189         internal Animatable _object
 190         {
 191             set
 192             {
 193                 NDalicPINVOKE.Property__object_set(swigCPtr, Animatable.getCPtr(value));
 194                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 195             }
 196             get
 197             {
 198                 Animatable ret = new Animatable(NDalicPINVOKE.Property__object_get(swigCPtr), false);
 199                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 200                 return ret;
 201             }
 202         }
 203
 204         /// <summary>
 205         /// Gets or sets the index of the property.
 206         /// </summary>
 207         /// <since_tizen> 3 </since_tizen>
 208         public int propertyIndex
 209         {
 210             set
 211             {
 212                 NDalicPINVOKE.Property_propertyIndex_set(swigCPtr, value);
 213                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 214             }
 215             get
 216             {
 217                 int ret = NDalicPINVOKE.Property_propertyIndex_get(swigCPtr);
 218                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 219                 return ret;
 220             }
 221         }
 222
 223         /// <summary>
 224         /// Gets or sets the component index of the property.
 225         /// </summary>
 226         /// <since_tizen> 3 </since_tizen>
 227         public int componentIndex
 228         {
 229             set
 230             {
 231                 NDalicPINVOKE.Property_componentIndex_set(swigCPtr, value);
 232                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 233             }
 234             get
 235             {
 236                 int ret = NDalicPINVOKE.Property_componentIndex_get(swigCPtr);
 237                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 238                 return ret;
 239             }
 240         }
 241
 242     }
 243
 244     /// <summary>
 245     /// An array of property values.
 246     /// </summary>
 247     /// <since_tizen> 3 </since_tizen>
 248     public class PropertyArray : global::System.IDisposable
 249     {
 250         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 251         /// <summary>
 252         /// swigCMemOwn
 253         /// </summary>
 254         /// <since_tizen> 3 </since_tizen>
 255         protected bool swigCMemOwn;
 256
 257         internal PropertyArray(global::System.IntPtr cPtr, bool cMemoryOwn)
 258         {
 259             swigCMemOwn = cMemoryOwn;
 260             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 261         }
 262
 263         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PropertyArray obj)
 264         {
 265             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 266         }
 267
 268         //A Flag to check who called Dispose(). (By User or DisposeQueue)
 269         private bool isDisposeQueued = false;
 270         /// <summary>
 271         /// A Flat to check if it is already disposed.
 272         /// </summary>
 273         /// <since_tizen> 3 </since_tizen>
 274         protected bool disposed = false;
 275
 276         /// <summary>
 277         /// Dispose.
 278         /// </summary>
 279         /// <since_tizen> 3 </since_tizen>
 280         ~PropertyArray()
 281         {
 282             if(!isDisposeQueued)
 283             {
 284                 isDisposeQueued = true;
 285                 DisposeQueue.Instance.Add(this);
 286             }
 287         }
 288
 289         /// <summary>
 290         /// Dispose.
 291         /// </summary>
 292         /// <since_tizen> 3 </since_tizen>
 293         public void Dispose()
 294         {
 295             //Throw excpetion if Dispose() is called in separate thread.
 296             if (!Window.IsInstalled())
 297             {
 298                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 299             }
 300
 301             if (isDisposeQueued)
 302             {
 303                 Dispose(DisposeTypes.Implicit);
 304             }
 305             else
 306             {
 307                 Dispose(DisposeTypes.Explicit);
 308                 System.GC.SuppressFinalize(this);
 309             }
 310         }
 311
 312         /// <summary>
 313         /// Dispose.
 314         /// </summary>
 315         /// <since_tizen> 3 </since_tizen>
 316         protected virtual void Dispose(DisposeTypes type)
 317         {
 318             if (disposed)
 319             {
 320                 return;
 321             }
 322
 323             if(type == DisposeTypes.Explicit)
 324             {
 325                 //Called by User
 326                 //Release your own managed resources here.
 327                 //You should release all of your own disposable objects here.
 328             }
 329
 330             //Release your own unmanaged resources here.
 331             //You should not access any managed member here except static instance.
 332             //because the execution order of Finalizes is non-deterministic.
 333
 334             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 335             {
 336                 if (swigCMemOwn)
 337                 {
 338                     swigCMemOwn = false;
 339                     NDalicPINVOKE.delete_Property_Array(swigCPtr);
 340                 }
 341                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 342             }
 343             disposed = true;
 344         }
 345
 346         /// <summary>
 347         /// The operator to access an element.
 348         /// </summary>
 349         /// <param name="index">The element index to access. No bounds checking is performed.</param>
 350         /// <returns>The reference to the element.</returns>
 351         /// <since_tizen> 3 </since_tizen>
 352         public PropertyValue this[uint index]
 353         {
 354             get
 355             {
 356                 return ValueOfIndex(index);
 357             }
 358         }
 359
 360         /// <summary>
 361         /// The constructor.
 362         /// </summary>
 363         /// <since_tizen> 3 </since_tizen>
 364         public PropertyArray() : this(NDalicPINVOKE.new_Property_Array__SWIG_0(), true)
 365         {
 366             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 367         }
 368
 369         internal PropertyArray(PropertyArray other) : this(NDalicPINVOKE.new_Property_Array__SWIG_1(PropertyArray.getCPtr(other)), true)
 370         {
 371             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 372         }
 373
 374         /// <summary>
 375         /// Retrieves the number of elements in the array.
 376         /// </summary>
 377         /// <returns>The number of elements in the array.</returns>
 378         /// <since_tizen> 3 </since_tizen>
 379         public uint Size()
 380         {
 381             uint ret = NDalicPINVOKE.Property_Array_Size(swigCPtr);
 382             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 383             return ret;
 384         }
 385
 386         /// <summary>
 387         /// Retrieves the number of elements in the array.
 388         /// </summary>
 389         /// <returns>The number of elements in the array.</returns>
 390         /// <since_tizen> 3 </since_tizen>
 391         public uint Count()
 392         {
 393             uint ret = NDalicPINVOKE.Property_Array_Count(swigCPtr);
 394             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 395             return ret;
 396         }
 397
 398         /// <summary>
 399         /// Returns whether the array is empty.
 400         /// </summary>
 401         /// <returns>Returns true if empty, false otherwise.</returns>
 402         /// <since_tizen> 3 </since_tizen>
 403         public bool Empty()
 404         {
 405             bool ret = NDalicPINVOKE.Property_Array_Empty(swigCPtr);
 406             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 407             return ret;
 408         }
 409
 410         /// <summary>
 411         /// Clears the array.
 412         /// </summary>
 413         /// <since_tizen> 3 </since_tizen>
 414         public void Clear()
 415         {
 416             NDalicPINVOKE.Property_Array_Clear(swigCPtr);
 417             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 418         }
 419
 420         /// <summary>
 421         /// Increases the capacity of the array.
 422         /// </summary>
 423         /// <param name="size">The size to reserve.</param>
 424         /// <since_tizen> 3 </since_tizen>
 425         public void Reserve(uint size)
 426         {
 427             NDalicPINVOKE.Property_Array_Reserve(swigCPtr, size);
 428             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 429         }
 430
 431         /// <summary>
 432         /// Resizes to size.
 433         /// </summary>
 434         /// <param name="size">The size to resize</param>
 435         /// <since_tizen> 3 </since_tizen>
 436         public void Resize(uint size)
 437         {
 438             NDalicPINVOKE.Property_Array_Resize(swigCPtr, size);
 439             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 440         }
 441
 442         /// <summary>
 443         /// Retrieves the capacity of the array.
 444         /// </summary>
 445         /// <returns>The allocated capacity of the array.</returns>
 446         /// <since_tizen> 3 </since_tizen>
 447         public uint Capacity()
 448         {
 449             uint ret = NDalicPINVOKE.Property_Array_Capacity(swigCPtr);
 450             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 451             return ret;
 452         }
 453
 454         /// <summary>
 455         /// Adds an element to the array.
 456         /// </summary>
 457         /// <param name="value">The value to add at the end of the array.</param>
 458         /// <since_tizen> 3 </since_tizen>
 459         public void PushBack(PropertyValue value)
 460         {
 461             NDalicPINVOKE.Property_Array_PushBack(swigCPtr, PropertyValue.getCPtr(value));
 462             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 463         }
 464
 465         /// <summary>
 466         /// Adds an element to the array.
 467         /// </summary>
 468         /// <param name="value">The value to add at the end of the array.</param>
 469         /// <since_tizen> 3 </since_tizen>
 470         public PropertyArray Add(PropertyValue value)
 471         {
 472             PropertyArray ret = new PropertyArray(NDalicPINVOKE.Property_Array_Add(swigCPtr, PropertyValue.getCPtr(value)), false);
 473             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 474             return ret;
 475         }
 476
 477         /// <summary>
 478         /// Accesses an element.
 479         /// </summary>
 480         /// <param name="index">The element index to access. No bounds checking is performed.</param>
 481         /// <returns>The reference to the element.</returns>
 482         /// <since_tizen> 3 </since_tizen>
 483         public PropertyValue GetElementAt(uint index)
 484         {
 485             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Array_GetElementAt__SWIG_0(swigCPtr, index), false);
 486             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 487             return ret;
 488         }
 489
 490         /// <summary>
 491         /// Retrieves the value of elements in the array.
 492         /// </summary>
 493         /// <param name="index">The element index to retrieve.</param>
 494         /// <returns>The reference to the element.</returns>
 495         private PropertyValue ValueOfIndex(uint index)
 496         {
 497             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Array_ValueOfIndex__SWIG_0(swigCPtr, index), false);
 498             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 499             return ret;
 500         }
 501     }
 502
 503     /// <summary>
 504     /// A key type which can be either a std::string or a Property::Index.
 505     /// </summary>
 506     /// <since_tizen> 3 </since_tizen>
 507     public class PropertyKey : global::System.IDisposable
 508     {
 509         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 510         /// <summary>
 511         /// swigCMemOwn
 512         /// </summary>
 513         /// <since_tizen> 3 </since_tizen>
 514         protected bool swigCMemOwn;
 515
 516         internal PropertyKey(global::System.IntPtr cPtr, bool cMemoryOwn)
 517         {
 518             swigCMemOwn = cMemoryOwn;
 519             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 520         }
 521
 522         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PropertyKey obj)
 523         {
 524             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 525         }
 526
 527         //A Flag to check who called Dispose(). (By User or DisposeQueue)
 528         private bool isDisposeQueued = false;
 529         /// <summary>
 530         /// A Flat to check if it is already disposed.
 531         /// </summary>
 532         /// <since_tizen> 3 </since_tizen>
 533         protected bool disposed = false;
 534
 535         /// <summary>
 536         /// Dispose.
 537         /// </summary>
 538         /// <since_tizen> 3 </since_tizen>
 539         ~PropertyKey()
 540         {
 541             if(!isDisposeQueued)
 542             {
 543                 isDisposeQueued = true;
 544                 DisposeQueue.Instance.Add(this);
 545             }
 546         }
 547
 548         /// <summary>
 549         /// Dispose.
 550         /// </summary>
 551         /// <since_tizen> 3 </since_tizen>
 552         public void Dispose()
 553         {
 554             //Throw excpetion if Dispose() is called in separate thread.
 555             if (!Window.IsInstalled())
 556             {
 557                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 558             }
 559
 560             if (isDisposeQueued)
 561             {
 562                 Dispose(DisposeTypes.Implicit);
 563             }
 564             else
 565             {
 566                 Dispose(DisposeTypes.Explicit);
 567                 System.GC.SuppressFinalize(this);
 568             }
 569         }
 570
 571         /// <summary>
 572         /// Dispose.
 573         /// </summary>
 574         /// <since_tizen> 3 </since_tizen>
 575         protected virtual void Dispose(DisposeTypes type)
 576         {
 577             if (disposed)
 578             {
 579                 return;
 580             }
 581
 582             if(type == DisposeTypes.Explicit)
 583             {
 584                 //Called by User
 585                 //Release your own managed resources here.
 586                 //You should release all of your own disposable objects here.
 587             }
 588
 589             //Release your own unmanaged resources here.
 590             //You should not access any managed member here except static instance.
 591             //because the execution order of Finalizes is non-deterministic.
 592
 593             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 594             {
 595                 if (swigCMemOwn)
 596                 {
 597                     swigCMemOwn = false;
 598                     NDalicPINVOKE.delete_Property_Key(swigCPtr);
 599                 }
 600                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 601             }
 602             disposed = true;
 603         }
 604
 605         /// <summary>
 606         /// The type of the key.
 607         /// </summary>
 608         /// <since_tizen> 3 </since_tizen>
 609         public PropertyKey.KeyType Type
 610         {
 611             set
 612             {
 613                 NDalicPINVOKE.Property_Key_type_set(swigCPtr, (int)value);
 614                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 615             }
 616             get
 617             {
 618                 PropertyKey.KeyType ret = (PropertyKey.KeyType)NDalicPINVOKE.Property_Key_type_get(swigCPtr);
 619                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 620                 return ret;
 621             }
 622         }
 623
 624         /// <summary>
 625         /// The index key.
 626         /// </summary>
 627         /// <since_tizen> 3 </since_tizen>
 628         public int IndexKey
 629         {
 630             set
 631             {
 632                 NDalicPINVOKE.Property_Key_indexKey_set(swigCPtr, value);
 633                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 634             }
 635             get
 636             {
 637                 int ret = NDalicPINVOKE.Property_Key_indexKey_get(swigCPtr);
 638                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 639                 return ret;
 640             }
 641         }
 642
 643         /// <summary>
 644         /// The string key.
 645         /// </summary>
 646         /// <since_tizen> 3 </since_tizen>
 647         public string StringKey
 648         {
 649             set
 650             {
 651                 NDalicPINVOKE.Property_Key_stringKey_set(swigCPtr, value);
 652                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 653             }
 654             get
 655             {
 656                 string ret = NDalicPINVOKE.Property_Key_stringKey_get(swigCPtr);
 657                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 658                 return ret;
 659             }
 660         }
 661
 662         /// <summary>
 663         /// The constructor.
 664         /// </summary>
 665         /// <param name="key">The string key.</param>
 666         /// <since_tizen> 3 </since_tizen>
 667         public PropertyKey(string key) : this(NDalicPINVOKE.new_Property_Key__SWIG_0(key), true)
 668         {
 669             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 670         }
 671
 672         /// <summary>
 673         /// The constructor.
 674         /// </summary>
 675         /// <param name="key">The index key.</param>
 676         /// <since_tizen> 3 </since_tizen>
 677         public PropertyKey(int key) : this(NDalicPINVOKE.new_Property_Key__SWIG_1(key), true)
 678         {
 679             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 680         }
 681
 682         /// <summary>
 683         /// Compares if rhs is equal to.
 684         /// </summary>
 685         /// <param name="rhs">A string key to compare against.</param>
 686         /// <returns>Returns true if the key compares, or false if it isn't equal or of the wrong type.</returns>
 687         /// <since_tizen> 3 </since_tizen>
 688         public bool EqualTo(string rhs)
 689         {
 690             bool ret = NDalicPINVOKE.Property_Key_EqualTo__SWIG_0(swigCPtr, rhs);
 691             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 692             return ret;
 693         }
 694
 695         /// <summary>
 696         /// Compares if rhs is equal to.
 697         /// </summary>
 698         /// <param name="rhs">The index key to compare against.</param>
 699         /// <returns>Returns true if the key compares, or false if it isn't equal or of the wrong type.</returns>
 700         /// <since_tizen> 3 </since_tizen>
 701         public bool EqualTo(int rhs)
 702         {
 703             bool ret = NDalicPINVOKE.Property_Key_EqualTo__SWIG_1(swigCPtr, rhs);
 704             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 705             return ret;
 706         }
 707
 708         /// <summary>
 709         /// Compares if rhs is equal to
 710         /// </summary>
 711         /// <param name="rhs">A key to compare against</param>
 712         /// <returns>Returns true if the keys are of the same type and have the same value.</returns>
 713         /// <since_tizen> 3 </since_tizen>
 714         public bool EqualTo(PropertyKey rhs)
 715         {
 716             bool ret = NDalicPINVOKE.Property_Key_EqualTo__SWIG_2(swigCPtr, PropertyKey.getCPtr(rhs));
 717             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 718             return ret;
 719         }
 720
 721         /// <summary>
 722         /// Compares if rhs is not equal to.
 723         /// </summary>
 724         /// <param name="rhs">The index key to compare against.</param>
 725         /// <returns>Returns true if the key is not equal or not a string key.</returns>
 726         /// <since_tizen> 3 </since_tizen>
 727         public bool NotEqualTo(string rhs)
 728         {
 729             bool ret = NDalicPINVOKE.Property_Key_NotEqualTo__SWIG_0(swigCPtr, rhs);
 730             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 731             return ret;
 732         }
 733
 734         /// <summary>
 735         /// Compares if rhs is not equal to.
 736         /// </summary>
 737         /// <param name="rhs">The index key to compare against.</param>
 738         /// <returns>Returns true if the key is not equal, or not the index key.</returns>
 739         /// <since_tizen> 3 </since_tizen>
 740         public bool NotEqualTo(int rhs)
 741         {
 742             bool ret = NDalicPINVOKE.Property_Key_NotEqualTo__SWIG_1(swigCPtr, rhs);
 743             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 744             return ret;
 745         }
 746
 747         /// <summary>
 748         /// Compares if rhs is not equal to.
 749         /// </summary>
 750         /// <param name="rhs">A key to compare against.</param>
 751         /// <returns>Returns true if the keys are not of the same type or are not equal.</returns>
 752         /// <since_tizen> 3 </since_tizen>
 753         public bool NotEqualTo(PropertyKey rhs)
 754         {
 755             bool ret = NDalicPINVOKE.Property_Key_NotEqualTo__SWIG_2(swigCPtr, PropertyKey.getCPtr(rhs));
 756             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 757             return ret;
 758         }
 759
 760         /// <summary>
 761         /// The type of key.
 762         /// </summary>
 763         /// <since_tizen> 3 </since_tizen>
 764         public enum KeyType
 765         {
 766             /// <summary>
 767             /// The type of key is index.
 768             /// </summary>
 769             /// <since_tizen> 3 </since_tizen>
 770             Index,
 771             /// <summary>
 772             /// The type of key is string.
 773             /// </summary>
 774             /// <since_tizen> 3 </since_tizen>
 775             String
 776         }
 777
 778     }
 779
 780     /// <summary>
 781     /// A map of property values, the key type could be string or Property::Index.
 782     /// </summary>
 783     /// <since_tizen> 3 </since_tizen>
 784     public class PropertyMap : global::System.IDisposable
 785     {
 786         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 787         /// <summary>
 788         /// swigCMemOwn
 789         /// </summary>
 790         /// <since_tizen> 3 </since_tizen>
 791         protected bool swigCMemOwn;
 792
 793         internal PropertyMap(global::System.IntPtr cPtr, bool cMemoryOwn)
 794         {
 795             swigCMemOwn = cMemoryOwn;
 796             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 797         }
 798
 799         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PropertyMap obj)
 800         {
 801             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 802         }
 803
 804         //A Flag to check who called Dispose(). (By User or DisposeQueue)
 805         private bool isDisposeQueued = false;
 806         /// <summary>
 807         /// A Flat to check if it is already disposed.
 808         /// </summary>
 809         /// <since_tizen> 3 </since_tizen>
 810         protected bool disposed = false;
 811
 812         /// <summary>
 813         /// Dispose.
 814         /// </summary>
 815         /// <since_tizen> 3 </since_tizen>
 816         ~PropertyMap()
 817         {
 818             if(!isDisposeQueued)
 819             {
 820                 isDisposeQueued = true;
 821                 DisposeQueue.Instance.Add(this);
 822             }
 823         }
 824
 825         /// <summary>
 826         /// Dispose.
 827         /// </summary>
 828         /// <since_tizen> 3 </since_tizen>
 829         public void Dispose()
 830         {
 831             //Throw excpetion if Dispose() is called in separate thread.
 832             if (!Window.IsInstalled())
 833             {
 834                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 835             }
 836
 837             if (isDisposeQueued)
 838             {
 839                 Dispose(DisposeTypes.Implicit);
 840             }
 841             else
 842             {
 843                 Dispose(DisposeTypes.Explicit);
 844                 System.GC.SuppressFinalize(this);
 845             }
 846         }
 847
 848         /// <summary>
 849         /// Dispose.
 850         /// </summary>
 851         /// <since_tizen> 3 </since_tizen>
 852         protected virtual void Dispose(DisposeTypes type)
 853         {
 854             if (disposed)
 855             {
 856                 return;
 857             }
 858
 859             if(type == DisposeTypes.Explicit)
 860             {
 861                 //Called by User
 862                 //Release your own managed resources here.
 863                 //You should release all of your own disposable objects here.
 864             }
 865
 866             //Release your own unmanaged resources here.
 867             //You should not access any managed member here except static instance.
 868             //because the execution order of Finalizes is non-deterministic.
 869
 870             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 871             {
 872                 if (swigCMemOwn)
 873                 {
 874                     swigCMemOwn = false;
 875                     NDalicPINVOKE.delete_Property_Map(swigCPtr);
 876                 }
 877                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 878             }
 879             disposed = true;
 880         }
 881
 882         /// <summary>
 883         /// The operator to access the element with the specified string key.<br />
 884         /// If an element with the key does not exist, then it is created.<br />
 885         /// </summary>
 886         /// <param name="key">The key whose value to access.</param>
 887         /// <returns>A value for the element with the specified key.</returns>
 888         /// <since_tizen> 3 </since_tizen>
 889         public PropertyValue this[string key]
 890         {
 891             get
 892             {
 893                 return ValueOfIndex(key);
 894             }
 895         }
 896
 897         /// <summary>
 898         /// The operator to access the element with the specified index key.<br />
 899         /// If an element with the key does not exist, then it is created.<br />
 900         /// </summary>
 901         /// <param name="key">The key whose value to access.</param>
 902         /// <returns>A value for the element with the specified key.</returns>
 903         /// <since_tizen> 3 </since_tizen>
 904         public PropertyValue this[int key]
 905         {
 906             get
 907             {
 908                 return ValueOfIndex(key);
 909             }
 910         }
 911
 912         /// <summary>
 913         /// The constructor.
 914         /// </summary>
 915         /// <since_tizen> 3 </since_tizen>
 916         public PropertyMap() : this(NDalicPINVOKE.new_Property_Map__SWIG_0(), true)
 917         {
 918             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 919         }
 920
 921         /// <summary>
 922         /// The copy constructor.
 923         /// </summary>
 924         /// <param name="other">The map to copy from.</param>
 925         /// <since_tizen> 3 </since_tizen>
 926         public PropertyMap(PropertyMap other) : this(NDalicPINVOKE.new_Property_Map__SWIG_1(PropertyMap.getCPtr(other)), true)
 927         {
 928             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 929         }
 930
 931         /// <summary>
 932         /// Retrieves the number of elements in the map.
 933         /// </summary>
 934         /// <returns>The number of elements in the map.</returns>
 935         /// <since_tizen> 3 </since_tizen>
 936         public uint Count()
 937         {
 938             uint ret = NDalicPINVOKE.Property_Map_Count(swigCPtr);
 939             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 940             return ret;
 941         }
 942
 943         /// <summary>
 944         /// Returns whether the map is empty.
 945         /// </summary>
 946         /// <returns>Returns true if empty, false otherwise.</returns>
 947         /// <since_tizen> 3 </since_tizen>
 948         public bool Empty()
 949         {
 950             bool ret = NDalicPINVOKE.Property_Map_Empty(swigCPtr);
 951             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 952             return ret;
 953         }
 954
 955         /// <summary>
 956         /// Inserts the key-value pair in the map, with the key type as string.<br />
 957         /// Does not check for duplicates.<br />
 958         /// </summary>
 959         /// <param name="key">The key to insert.</param>
 960         /// <param name="value">The value to insert.</param>
 961         /// <since_tizen> 3 </since_tizen>
 962         public void Insert(string key, PropertyValue value)
 963         {
 964             NDalicPINVOKE.Property_Map_Insert__SWIG_0(swigCPtr, key, PropertyValue.getCPtr(value));
 965             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 966         }
 967
 968         /// <summary>
 969         /// Inserts the key-value pair in the map, with the key type as index.<br />
 970         /// Does not check for duplicates.<br />
 971         /// </summary>
 972         /// <param name="key">The key to insert.</param>
 973         /// <param name="value">The value to insert.</param>
 974         /// <since_tizen> 3 </since_tizen>
 975         public void Insert(int key, PropertyValue value)
 976         {
 977             NDalicPINVOKE.Property_Map_Insert__SWIG_2(swigCPtr, key, PropertyValue.getCPtr(value));
 978             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 979         }
 980
 981         /// <summary>
 982         /// Inserts the key-value pair in the map, with the key type as string.<br />
 983         /// Does not check for duplicates.<br />
 984         /// </summary>
 985         /// <param name="key">The key to insert.</param>
 986         /// <param name="value">The value to insert.</param>
 987         /// <returns>Returns a reference to this object.</returns>
 988         /// <since_tizen> 3 </since_tizen>
 989         public PropertyMap Add(string key, PropertyValue value)
 990         {
 991             PropertyMap ret = new PropertyMap(NDalicPINVOKE.Property_Map_Add__SWIG_0(swigCPtr, key, PropertyValue.getCPtr(value)), false);
 992             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 993             return ret;
 994         }
 995
 996         /// <summary>
 997         /// Inserts the key-value pair in the map, with the key type as string.<br />
 998         /// Does not check for duplicates.<br />
 999         /// </summary>
1000         /// <param name="key">The key to insert.</param>
1001         /// <param name="value">The value to insert.</param>
1002         /// <returns>Returns a reference to this object.</returns>
1003         /// <since_tizen> 3 </since_tizen>
1004         public PropertyMap Add(int key, PropertyValue value)
1005         {
1006             PropertyMap ret = new PropertyMap(NDalicPINVOKE.Property_Map_Add__SWIG_2(swigCPtr, key, PropertyValue.getCPtr(value)), false);
1007             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1008             return ret;
1009         }
1010
1011         /// <summary>
1012         /// Retrieves the value at the specified position.
1013         /// </summary>
1014         /// <param name="position">The specified position.</param>
1015         /// <returns>A reference to the value at the specified position.</returns>
1016         /// <since_tizen> 3 </since_tizen>
1017         public PropertyValue GetValue(uint position)
1018         {
1019             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_GetValue(swigCPtr, position), false);
1020             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1021             return ret;
1022         }
1023
1024         /// <summary>
1025         /// Please do not use! this will be deprecated.
1026         /// </summary>
1027         /// <since_tizen> 3 </since_tizen>
1028         [Obsolete("Please do not use! This will be deprecated!")]
1029         [EditorBrowsable(EditorBrowsableState.Never)]
1030         public string GetKey(uint position)
1031         {
1032             string ret = NDalicPINVOKE.Property_Map_GetKey(swigCPtr, position);
1033             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1034             return ret;
1035         }
1036
1037         /// <summary>
1038         /// Retrieves the key at the specified position.
1039         /// </summary>
1040         /// <param name="position">The specified position.</param>
1041         /// <returns>A copy of the key at the specified position.</returns>
1042         /// <since_tizen> 3 </since_tizen>
1043         public PropertyKey GetKeyAt(uint position)
1044         {
1045             PropertyKey ret = new PropertyKey(NDalicPINVOKE.Property_Map_GetKeyAt(swigCPtr, position), true);
1046             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1047             return ret;
1048         }
1049
1050         /// <summary>
1051         /// Please do not use! this will be deprecated
1052         /// </summary>
1053         /// <since_tizen> 3 </since_tizen>
1054         [Obsolete("Please do not use! This will be deprecated!")]
1055         [EditorBrowsable(EditorBrowsableState.Never)]
1056         public PropertyValue Find(string key)
1057         {
1058             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_0(swigCPtr, key);
1059             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1060             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1061             return ret;
1062         }
1063
1064         /// <summary>
1065         /// Finds the value for the specified key if it exists.
1066         /// </summary>
1067         /// <param name="key">The key to find.</param>
1068         /// <returns>The value if it exists, an empty object otherwise.</returns>
1069         /// <since_tizen> 3 </since_tizen>
1070         public PropertyValue Find(int key)
1071         {
1072             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_2(swigCPtr, key);
1073             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1074             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1075             return ret;
1076         }
1077
1078         /// <summary>
1079         /// Finds the value for the specified keys if either exist.
1080         /// </summary>
1081         /// <param name="indexKey">The index key to find.</param>
1082         /// <param name="stringKey">The string key to find.</param>
1083         /// <returns>The value if it exists, an empty object otherwise.</returns>
1084         /// <since_tizen> 3 </since_tizen>
1085         public PropertyValue Find(int indexKey, string stringKey)
1086         {
1087             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_3(swigCPtr, indexKey, stringKey);
1088             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1089             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1090             return ret;
1091         }
1092
1093         /// <summary>
1094         /// Please do not use! this will be deprecated.
1095         /// </summary>
1096         /// <since_tizen> 3 </since_tizen>
1097         [Obsolete("Please do not use! This will be deprecated!")]
1098         [EditorBrowsable(EditorBrowsableState.Never)]
1099         public PropertyValue Find(string key, PropertyType type)
1100         {
1101             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_4(swigCPtr, key, (int)type);
1102             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1103             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1104             return ret;
1105         }
1106
1107         /// <summary>
1108         /// Please do not use! this will be deprecated
1109         /// </summary>
1110         /// <since_tizen> 3 </since_tizen>
1111         [Obsolete("Please do not use! This will be deprecated!")]
1112         [EditorBrowsable(EditorBrowsableState.Never)]
1113         public PropertyValue Find(int key, PropertyType type)
1114         {
1115             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_5(swigCPtr, key, (int)type);
1116             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1117             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1118             return ret;
1119         }
1120
1121         /// <summary>
1122         /// Clears the map.
1123         /// </summary>
1124         /// <since_tizen> 3 </since_tizen>
1125         public void Clear()
1126         {
1127             NDalicPINVOKE.Property_Map_Clear(swigCPtr);
1128             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1129         }
1130
1131         /// <summary>
1132         /// Merges values from the map 'from' to the current.<br />
1133         /// Any values in 'from' will overwrite the values in the current map.<br />
1134         /// </summary>
1135         /// <param name="from">The map to merge from.</param>
1136         /// <since_tizen> 3 </since_tizen>
1137         public void Merge(PropertyMap from)
1138         {
1139             NDalicPINVOKE.Property_Map_Merge(swigCPtr, PropertyMap.getCPtr(from));
1140             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1141         }
1142
1143         /// <summary>
1144         /// Retrieves the element with the specified string key.
1145         /// </summary>
1146         /// <param name="key">The key whose value to retrieve.</param>
1147         /// <returns>The value for the element with the specified key.</returns>
1148         internal PropertyValue ValueOfIndex(string key)
1149         {
1150             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_ValueOfIndex__SWIG_0(swigCPtr, key), false);
1151             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1152             return ret;
1153         }
1154
1155         /// <summary>
1156         /// Retrieves the element with the specified index key.
1157         /// </summary>
1158         /// <param name="key">The key whose value to retrieve.</param>
1159         /// <returns>The value for the element with the specified key.</returns>
1160         internal PropertyValue ValueOfIndex(int key)
1161         {
1162             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_ValueOfIndex__SWIG_2(swigCPtr, key), false);
1163             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1164             return ret;
1165         }
1166     }
1167
1168     /// <summary>
1169     /// A value-type representing a property value.
1170     /// </summary>
1171     /// <since_tizen> 3 </since_tizen>
1172     public class PropertyValue : global::System.IDisposable
1173     {
1174         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
1175         /// <summary>
1176         /// swigCMemOwn
1177         /// </summary>
1178         /// <since_tizen> 3 </since_tizen>
1179         protected bool swigCMemOwn;
1180
1181         internal PropertyValue(global::System.IntPtr cPtr, bool cMemoryOwn)
1182         {
1183             swigCMemOwn = cMemoryOwn;
1184             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
1185         }
1186
1187         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PropertyValue obj)
1188         {
1189             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1190         }
1191
1192         //A Flag to check who called Dispose(). (By User or DisposeQueue)
1193         private bool isDisposeQueued = false;
1194         /// <summary>
1195         /// A Flat to check if it is already disposed.
1196         /// </summary>
1197         /// <since_tizen> 3 </since_tizen>
1198         protected bool disposed = false;
1199
1200         /// <summary>
1201         /// Dispose.
1202         /// </summary>
1203         /// <since_tizen> 3 </since_tizen>
1204         ~PropertyValue()
1205         {
1206             if(!isDisposeQueued)
1207             {
1208                 isDisposeQueued = true;
1209                 DisposeQueue.Instance.Add(this);
1210             }
1211         }
1212
1213         /// <summary>
1214         /// Dispose.
1215         /// </summary>
1216         /// <since_tizen> 3 </since_tizen>
1217         public void Dispose()
1218         {
1219             //Throw excpetion if Dispose() is called in separate thread.
1220             if (!Window.IsInstalled())
1221             {
1222                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
1223             }
1224
1225             if (isDisposeQueued)
1226             {
1227                 Dispose(DisposeTypes.Implicit);
1228             }
1229             else
1230             {
1231                 Dispose(DisposeTypes.Explicit);
1232                 System.GC.SuppressFinalize(this);
1233             }
1234         }
1235
1236         /// <summary>
1237         /// Dispose.
1238         /// </summary>
1239         /// <since_tizen> 3 </since_tizen>
1240         protected virtual void Dispose(DisposeTypes type)
1241         {
1242             if (disposed)
1243             {
1244                 return;
1245             }
1246
1247             if(type == DisposeTypes.Explicit)
1248             {
1249                 //Called by User
1250                 //Release your own managed resources here.
1251                 //You should release all of your own disposable objects here.
1252             }
1253
1254             //Release your own unmanaged resources here.
1255             //You should not access any managed member here except static instance.
1256             //because the execution order of Finalizes is non-deterministic.
1257
1258             if (swigCPtr.Handle != global::System.IntPtr.Zero)
1259             {
1260                 if (swigCMemOwn)
1261                 {
1262                     swigCMemOwn = false;
1263                     NDalicPINVOKE.delete_Property_Value(swigCPtr);
1264                 }
1265                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1266             }
1267             disposed = true;
1268         }
1269
1270
1271         /// <summary>
1272         /// An extension to the property value class that allows us to create a
1273         /// Property value from a C# object, for example, integer, float, or string.<br />
1274         /// </summary>
1275         /// <param name="obj">An object to create.</param>
1276         /// <returns>The created value.</returns>
1277         /// <since_tizen> 3 </since_tizen>
1278         static public PropertyValue CreateFromObject(System.Object obj)
1279         {
1280             System.Type type = obj.GetType();
1281
1282             PropertyValue value;
1283
1284             if (type.Equals(typeof(int)))
1285             {
1286                 value = new PropertyValue((int)obj);
1287             }
1288             if (type.Equals(typeof(System.Int32)))
1289             {
1290                 value = new PropertyValue((int)obj);
1291             }
1292             else if (type.Equals(typeof(bool)))
1293             {
1294                 value = new PropertyValue((bool)obj);
1295             }
1296             else if (type.Equals(typeof(float)))
1297             {
1298                 value = new PropertyValue((float)obj);
1299             }
1300             else if (type.Equals(typeof(string)))
1301             {
1302                 value = new PropertyValue((string)obj);
1303             }
1304             else if (type.Equals(typeof(Vector2)))
1305             {
1306                 value = new PropertyValue((Vector2)obj);
1307             }
1308             else if (type.Equals(typeof(Vector3)))
1309             {
1310                 value = new PropertyValue((Vector3)obj);
1311             }
1312             else if (type.Equals(typeof(Vector4)))
1313             {
1314                 value = new PropertyValue((Vector4)obj);
1315             }
1316             else if (type.Equals(typeof(Position)))
1317             {
1318                 value = new PropertyValue((Position)obj);
1319             }
1320             else if (type.Equals(typeof(Position2D)))
1321             {
1322                 value = new PropertyValue((Position2D)obj);
1323             }
1324             else if (type.Equals(typeof(Size)))
1325             {
1326                 value = new PropertyValue((Size)obj);
1327             }
1328             else if (type.Equals(typeof(Size2D)))
1329             {
1330                 value = new PropertyValue((Size2D)obj);
1331             }
1332             else if (type.Equals(typeof(Color)))
1333             {
1334                 value = new PropertyValue((Color)obj);
1335             }
1336             else if (type.Equals(typeof(Rotation)))
1337             {
1338                 value = new PropertyValue((Rotation)obj);
1339             }
1340             else if (type.Equals(typeof(RelativeVector2)))
1341             {
1342                 value = new PropertyValue((RelativeVector2)obj);
1343             }
1344             else if (type.Equals(typeof(RelativeVector3)))
1345             {
1346                 value = new PropertyValue((RelativeVector3)obj);
1347             }
1348             else if (type.Equals(typeof(RelativeVector4)))
1349             {
1350                 value = new PropertyValue((RelativeVector4)obj);
1351             }
1352             else if(type.Equals(typeof(Extents)))
1353             {
1354                 value = new PropertyValue((Extents)obj);
1355             }
1356             else
1357             {
1358                 throw new global::System.InvalidOperationException("Unimplemented type for Property Value :" + type.Name);
1359             }
1360             NUILog.Debug(" got an property value of =" + type.Name);
1361             return value;
1362         }
1363
1364         /// <summary>
1365         /// Creates a Size2D property value.
1366         /// </summary>
1367         /// <param name="vectorValue">Size2D values.</param>
1368         /// <since_tizen> 3 </since_tizen>
1369         public PropertyValue(Size2D vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Size2D.getCPtr(vectorValue)), true)
1370         {
1371             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1372         }
1373
1374         /// <summary>
1375         /// Creates a Position2D property value.
1376         /// </summary>
1377         /// <param name="vectorValue">Position2D values.</param>
1378         /// <since_tizen> 3 </since_tizen>
1379         public PropertyValue(Position2D vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Position2D.getCPtr(vectorValue)), true)
1380         {
1381             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1382         }
1383
1384         /// <summary>
1385         /// Creates a Size property value.
1386         /// </summary>
1387         /// <param name="vectorValue">Size values.</param>
1388         internal PropertyValue(Size vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Size.getCPtr(vectorValue)), true)
1389         {
1390             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1391         }
1392
1393         /// <summary>
1394         /// Creates a Position property value.
1395         /// </summary>
1396         /// <param name="vectorValue">Position values.</param>
1397         /// <since_tizen> 3 </since_tizen>
1398         public PropertyValue(Position vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Position.getCPtr(vectorValue)), true)
1399         {
1400             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1401         }
1402
1403         /// <summary>
1404         /// Creates a Color property value.
1405         /// </summary>
1406         /// <param name="vectorValue">Color values.</param>
1407         /// <since_tizen> 3 </since_tizen>
1408         public PropertyValue(Color vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_6(Color.getCPtr(vectorValue)), true)
1409         {
1410             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1411         }
1412
1413
1414         /// <summary>
1415         /// Retrieves a Size2D value.
1416         /// </summary>
1417         /// <param name="vectorValue"> On return, a Size2D value.</param>
1418         /// <since_tizen> 3 </since_tizen>
1419         public bool Get(Size2D vectorValue)
1420         {
1421             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Size2D.getCPtr(vectorValue));
1422             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1423             return ret;
1424         }
1425
1426         /// <summary>
1427         /// Retrieves a Position2D value.
1428         /// </summary>
1429         /// <param name="vectorValue"> On return, a Position2D value.</param>
1430         /// <since_tizen> 3 </since_tizen>
1431         public bool Get(Position2D vectorValue)
1432         {
1433             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Position2D.getCPtr(vectorValue));
1434             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1435             return ret;
1436         }
1437
1438         /// <summary>
1439         /// Retrieves a Size value.
1440         /// </summary>
1441         /// <param name="vectorValue"> On return, a size value.</param>
1442         internal bool Get(Size vectorValue)
1443         {
1444             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Size.getCPtr(vectorValue));
1445             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1446             return ret;
1447         }
1448
1449         /// <summary>
1450         /// Retrieves a Position value.
1451         /// </summary>
1452         /// <param name="vectorValue"> On return, a position value.</param>
1453         /// <since_tizen> 3 </since_tizen>
1454         public bool Get(Position vectorValue)
1455         {
1456             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Position.getCPtr(vectorValue));
1457             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1458             return ret;
1459         }
1460
1461         /// <summary>
1462         /// Retrieves a Color value.
1463         /// </summary>
1464         /// <param name="vectorValue"> On return, a color value.</param>
1465         /// <since_tizen> 3 </since_tizen>
1466         public bool Get(Color vectorValue)
1467         {
1468             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_7(swigCPtr, Color.getCPtr(vectorValue));
1469             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1470             return ret;
1471         }
1472
1473
1474
1475         /// <summary>
1476         /// The default constructor.
1477         /// </summary>
1478         /// <since_tizen> 3 </since_tizen>
1479         public PropertyValue() : this(NDalicPINVOKE.new_Property_Value__SWIG_0(), true)
1480         {
1481             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1482         }
1483
1484         /// <summary>
1485         /// Creates a boolean property value.
1486         /// </summary>
1487         /// <param name="boolValue">A boolean value.</param>
1488         /// <since_tizen> 3 </since_tizen>
1489         public PropertyValue(bool boolValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_1(boolValue), true)
1490         {
1491             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1492         }
1493
1494         /// <summary>
1495         /// Creates an integer property value.
1496         /// </summary>
1497         /// <param name="integerValue">An integer value.</param>
1498         /// <since_tizen> 3 </since_tizen>
1499         public PropertyValue(int integerValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_2(integerValue), true)
1500         {
1501             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1502         }
1503
1504         /// <summary>
1505         /// Creates a float property value.
1506         /// </summary>
1507         /// <param name="floatValue">A floating-point value.</param>
1508         /// <since_tizen> 3 </since_tizen>
1509         public PropertyValue(float floatValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_3(floatValue), true)
1510         {
1511             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1512         }
1513
1514         /// <summary>
1515         /// Creates a Vector2 property value.
1516         /// </summary>
1517         /// <param name="vectorValue">A vector of 2 floating-point values.</param>
1518         /// <since_tizen> 3 </since_tizen>
1519         public PropertyValue(Vector2 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Vector2.getCPtr(vectorValue)), true)
1520         {
1521             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1522         }
1523
1524         /// <summary>
1525         /// Creates a Vector3 property value.
1526         /// </summary>
1527         /// <param name="vectorValue">A vector of 3 floating-point values.</param>
1528         /// <since_tizen> 3 </since_tizen>
1529         public PropertyValue(Vector3 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Vector3.getCPtr(vectorValue)), true)
1530         {
1531             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1532         }
1533
1534         /// <summary>
1535         /// Creates a Vector4 property value.
1536         /// </summary>
1537         /// <param name="vectorValue">A vector of 4 floating-point values.</param>
1538         /// <since_tizen> 3 </since_tizen>
1539         public PropertyValue(Vector4 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_6(Vector4.getCPtr(vectorValue)), true)
1540         {
1541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1542         }
1543
1544         internal PropertyValue(Matrix3 matrixValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_7(Matrix3.getCPtr(matrixValue)), true)
1545         {
1546             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1547         }
1548
1549         internal PropertyValue(Matrix matrixValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_8(Matrix.getCPtr(matrixValue)), true)
1550         {
1551             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1552         }
1553
1554         /// <summary>
1555         /// Creates a Rectangle property value.
1556         /// </summary>
1557         /// <param name="vectorValue">Rectangle values.</param>
1558         /// <since_tizen> 3 </since_tizen>
1559         public PropertyValue(Rectangle vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_9(Rectangle.getCPtr(vectorValue)), true)
1560         {
1561             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1562         }
1563
1564         internal PropertyValue(AngleAxis angleAxis) : this(NDalicPINVOKE.new_Property_Value__SWIG_10(AngleAxis.getCPtr(angleAxis)), true)
1565         {
1566             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1567         }
1568
1569         /// <summary>
1570         /// Creates a Rotation property value.
1571         /// </summary>
1572         /// <param name="quaternion">Rotation values.</param>
1573         /// <since_tizen> 3 </since_tizen>
1574         public PropertyValue(Rotation quaternion) : this(NDalicPINVOKE.new_Property_Value__SWIG_11(Rotation.getCPtr(quaternion)), true)
1575         {
1576             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1577         }
1578
1579         /// <summary>
1580         /// Creates a string property value.
1581         /// </summary>
1582         /// <param name="stringValue">A string.</param>
1583         /// <since_tizen> 3 </since_tizen>
1584         public PropertyValue(string stringValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_12(stringValue), true)
1585         {
1586             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1587         }
1588
1589         /// <summary>
1590         /// Creates an array property value.
1591         /// </summary>
1592         /// <param name="arrayValue">An array.</param>
1593         /// <since_tizen> 3 </since_tizen>
1594         public PropertyValue(PropertyArray arrayValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_14(PropertyArray.getCPtr(arrayValue)), true)
1595         {
1596             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1597         }
1598
1599         /// <summary>
1600         /// Creates a map property value.
1601         /// </summary>
1602         /// <param name="mapValue">An array.</param>
1603         /// <since_tizen> 3 </since_tizen>
1604         public PropertyValue(PropertyMap mapValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_15(PropertyMap.getCPtr(mapValue)), true)
1605         {
1606             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1607         }
1608
1609         /// <summary>
1610         /// Creates a Extents value.
1611         /// </summary>
1612         /// <param name="extentsValue">A Extents value.</param>
1613         /// <since_tizen> 4 </since_tizen>
1614         public PropertyValue(Extents extentsValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_16(Extents.getCPtr(extentsValue)), true)
1615         {
1616             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1617         }
1618
1619         /// <summary>
1620         /// Creates a PropertyType value.
1621         /// </summary>
1622         /// <param name="type">A PropertyType value.</param>
1623         /// <since_tizen> 3 </since_tizen>
1624         public PropertyValue(PropertyType type) : this(NDalicPINVOKE.new_Property_Value__SWIG_17((int)type), true)
1625         {
1626             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1627         }
1628
1629         /// <summary>
1630         /// Creates a PropertyValue value.
1631         /// </summary>
1632         /// <param name="value">A PropertyValue value.</param>
1633         /// <since_tizen> 3 </since_tizen>
1634         public PropertyValue(PropertyValue value) : this(NDalicPINVOKE.new_Property_Value__SWIG_18(PropertyValue.getCPtr(value)), true)
1635         {
1636             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1637         }
1638
1639         /// <summary>
1640         /// Queries the type of this property value.
1641         /// </summary>
1642         /// <returns>The type ID</returns>
1643         /// <since_tizen> 3 </since_tizen>
1644         public new PropertyType GetType()
1645         {
1646             PropertyType ret = (PropertyType)NDalicPINVOKE.Property_Value_GetType(swigCPtr);
1647             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1648             return ret;
1649         }
1650
1651         /// <summary>
1652         /// Retrieves a boolean value.
1653         /// </summary>
1654         /// <param name="boolValue">On return, a boolean value.</param>
1655         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1656         /// <since_tizen> 3 </since_tizen>
1657         public bool Get(out bool boolValue)
1658         {
1659             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_1(swigCPtr, out boolValue);
1660             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1661             return ret;
1662         }
1663
1664         /// <summary>
1665         /// Retrieves a floating-point value.
1666         /// </summary>
1667         /// <param name="floatValue">On return, a floating-point value.</param>
1668         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1669         /// <since_tizen> 3 </since_tizen>
1670         public bool Get(out float floatValue)
1671         {
1672             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_2(swigCPtr, out floatValue);
1673             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1674             return ret;
1675         }
1676
1677         /// <summary>
1678         /// Retrieves an integer value.
1679         /// </summary>
1680         /// <param name="integerValue">On return, an integer value.</param>
1681         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1682         /// <since_tizen> 3 </since_tizen>
1683         public bool Get(out int integerValue)
1684         {
1685             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_3(swigCPtr, out integerValue);
1686             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1687             return ret;
1688         }
1689
1690         /// <summary>
1691         /// Retrieves an integer rectangle.
1692         /// </summary>
1693         /// <param name="rect">On return, an integer rectangle.</param>
1694         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1695         /// <since_tizen> 3 </since_tizen>
1696         public bool Get(Rectangle rect)
1697         {
1698             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_4(swigCPtr, Rectangle.getCPtr(rect));
1699             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1700             return ret;
1701         }
1702
1703         /// <summary>
1704         /// Retrieves a vector value.
1705         /// </summary>
1706         /// <param name="vectorValue">On return, a vector value.</param>
1707         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1708         /// <since_tizen> 3 </since_tizen>
1709         public bool Get(Vector2 vectorValue)
1710         {
1711             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Vector2.getCPtr(vectorValue));
1712             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1713             return ret;
1714         }
1715
1716         /// <summary>
1717         /// Retrieves a vector value.
1718         /// </summary>
1719         /// <param name="vectorValue">On return, a vector value.</param>
1720         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1721         /// <since_tizen> 3 </since_tizen>
1722         public bool Get(Vector3 vectorValue)
1723         {
1724             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Vector3.getCPtr(vectorValue));
1725             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1726             return ret;
1727         }
1728
1729         /// <summary>
1730         /// Retrieves a vector value.
1731         /// </summary>
1732         /// <param name="vectorValue">On return, a vector value.</param>
1733         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1734         /// <since_tizen> 3 </since_tizen>
1735         public bool Get(Vector4 vectorValue)
1736         {
1737             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_7(swigCPtr, Vector4.getCPtr(vectorValue));
1738             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1739             return ret;
1740         }
1741
1742         internal bool Get(Matrix3 matrixValue)
1743         {
1744             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_8(swigCPtr, Matrix3.getCPtr(matrixValue));
1745             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1746             return ret;
1747         }
1748
1749         internal bool Get(Matrix matrixValue)
1750         {
1751             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_9(swigCPtr, Matrix.getCPtr(matrixValue));
1752             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1753             return ret;
1754         }
1755
1756         internal bool Get(AngleAxis angleAxisValue)
1757         {
1758             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_10(swigCPtr, AngleAxis.getCPtr(angleAxisValue));
1759             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1760             return ret;
1761         }
1762
1763         /// <summary>
1764         /// Retrieves a Rotation value.
1765         /// </summary>
1766         /// <param name="quaternionValue">On return, a rotation value.</param>
1767         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1768         /// <since_tizen> 3 </since_tizen>
1769         public bool Get(Rotation quaternionValue)
1770         {
1771             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_11(swigCPtr, Rotation.getCPtr(quaternionValue));
1772             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1773             return ret;
1774         }
1775
1776         /// <summary>
1777         /// Retrieves a string property value.
1778         /// </summary>
1779         /// <param name="stringValue">On return, a string.</param>
1780         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1781         /// <since_tizen> 3 </since_tizen>
1782         public bool Get(out string stringValue)
1783         {
1784             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_12(swigCPtr, out stringValue);
1785             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1786             return ret;
1787         }
1788
1789         /// <summary>
1790         /// Retrieves an array property value.
1791         /// </summary>
1792         /// <param name="arrayValue">On return, the array as a vector property values.</param>
1793         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1794         /// <since_tizen> 3 </since_tizen>
1795         public bool Get(PropertyArray arrayValue)
1796         {
1797             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_13(swigCPtr, PropertyArray.getCPtr(arrayValue));
1798             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1799             return ret;
1800         }
1801
1802         /// <summary>
1803         /// Retrieves a map property value.
1804         /// </summary>
1805         /// <param name="mapValue">On return, the map as vector of string and property value pairs.</param>
1806         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1807         /// <since_tizen> 3 </since_tizen>
1808         public bool Get(PropertyMap mapValue)
1809         {
1810             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_14(swigCPtr, PropertyMap.getCPtr(mapValue));
1811             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1812             return ret;
1813         }
1814
1815         /// <summary>
1816         /// Retrieves a Extents value.
1817         /// </summary>
1818         /// <param name="extentsValue">On return, a extents.</param>
1819         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1820         /// <since_tizen> 4 </since_tizen>
1821         public bool Get(Extents extentsValue)
1822         {
1823             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_15(swigCPtr, Extents.getCPtr(extentsValue));
1824             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1825             return ret;
1826         }
1827     }
1828 }