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         /// Retrieves the key at the specified position.
1026         /// </summary>
1027         /// <param name="position">The specified position.</param>
1028         /// <returns>A copy of the key at the specified position.</returns>
1029         /// <since_tizen> 3 </since_tizen>
1030         public PropertyKey GetKeyAt(uint position)
1031         {
1032             PropertyKey ret = new PropertyKey(NDalicPINVOKE.Property_Map_GetKeyAt(swigCPtr, position), true);
1033             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1034             return ret;
1035         }
1036
1037         /// <summary>
1038         /// Finds the value for the specified key if it exists.
1039         /// </summary>
1040         /// <param name="key">The key to find.</param>
1041         /// <returns>The value if it exists, an empty object otherwise.</returns>
1042         /// <since_tizen> 3 </since_tizen>
1043         public PropertyValue Find(int key)
1044         {
1045             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_2(swigCPtr, key);
1046             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1047             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1048             return ret;
1049         }
1050
1051         /// <summary>
1052         /// Finds the value for the specified keys if either exist.
1053         /// </summary>
1054         /// <param name="indexKey">The index key to find.</param>
1055         /// <param name="stringKey">The string key to find.</param>
1056         /// <returns>The value if it exists, an empty object otherwise.</returns>
1057         /// <since_tizen> 3 </since_tizen>
1058         public PropertyValue Find(int indexKey, string stringKey)
1059         {
1060             global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_3(swigCPtr, indexKey, stringKey);
1061             PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
1062             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1063             return ret;
1064         }
1065
1066         /// <summary>
1067         /// Clears the map.
1068         /// </summary>
1069         /// <since_tizen> 3 </since_tizen>
1070         public void Clear()
1071         {
1072             NDalicPINVOKE.Property_Map_Clear(swigCPtr);
1073             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1074         }
1075
1076         /// <summary>
1077         /// Merges values from the map 'from' to the current.<br />
1078         /// Any values in 'from' will overwrite the values in the current map.<br />
1079         /// </summary>
1080         /// <param name="from">The map to merge from.</param>
1081         /// <since_tizen> 3 </since_tizen>
1082         public void Merge(PropertyMap from)
1083         {
1084             NDalicPINVOKE.Property_Map_Merge(swigCPtr, PropertyMap.getCPtr(from));
1085             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1086         }
1087
1088         /// <summary>
1089         /// Retrieves the element with the specified string key.
1090         /// </summary>
1091         /// <param name="key">The key whose value to retrieve.</param>
1092         /// <returns>The value for the element with the specified key.</returns>
1093         internal PropertyValue ValueOfIndex(string key)
1094         {
1095             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_ValueOfIndex__SWIG_0(swigCPtr, key), false);
1096             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1097             return ret;
1098         }
1099
1100         /// <summary>
1101         /// Retrieves the element with the specified index key.
1102         /// </summary>
1103         /// <param name="key">The key whose value to retrieve.</param>
1104         /// <returns>The value for the element with the specified key.</returns>
1105         internal PropertyValue ValueOfIndex(int key)
1106         {
1107             PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_ValueOfIndex__SWIG_2(swigCPtr, key), false);
1108             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1109             return ret;
1110         }
1111     }
1112
1113     /// <summary>
1114     /// A value-type representing a property value.
1115     /// </summary>
1116     /// <since_tizen> 3 </since_tizen>
1117     public class PropertyValue : global::System.IDisposable
1118     {
1119         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
1120         /// <summary>
1121         /// swigCMemOwn
1122         /// </summary>
1123         /// <since_tizen> 3 </since_tizen>
1124         protected bool swigCMemOwn;
1125
1126         internal PropertyValue(global::System.IntPtr cPtr, bool cMemoryOwn)
1127         {
1128             swigCMemOwn = cMemoryOwn;
1129             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
1130         }
1131
1132         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PropertyValue obj)
1133         {
1134             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1135         }
1136
1137         //A Flag to check who called Dispose(). (By User or DisposeQueue)
1138         private bool isDisposeQueued = false;
1139         /// <summary>
1140         /// A Flat to check if it is already disposed.
1141         /// </summary>
1142         /// <since_tizen> 3 </since_tizen>
1143         protected bool disposed = false;
1144
1145         /// <summary>
1146         /// Dispose.
1147         /// </summary>
1148         /// <since_tizen> 3 </since_tizen>
1149         ~PropertyValue()
1150         {
1151             if(!isDisposeQueued)
1152             {
1153                 isDisposeQueued = true;
1154                 DisposeQueue.Instance.Add(this);
1155             }
1156         }
1157
1158         /// <summary>
1159         /// Dispose.
1160         /// </summary>
1161         /// <since_tizen> 3 </since_tizen>
1162         public void Dispose()
1163         {
1164             //Throw excpetion if Dispose() is called in separate thread.
1165             if (!Window.IsInstalled())
1166             {
1167                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
1168             }
1169
1170             if (isDisposeQueued)
1171             {
1172                 Dispose(DisposeTypes.Implicit);
1173             }
1174             else
1175             {
1176                 Dispose(DisposeTypes.Explicit);
1177                 System.GC.SuppressFinalize(this);
1178             }
1179         }
1180
1181         /// <summary>
1182         /// Dispose.
1183         /// </summary>
1184         /// <since_tizen> 3 </since_tizen>
1185         protected virtual void Dispose(DisposeTypes type)
1186         {
1187             if (disposed)
1188             {
1189                 return;
1190             }
1191
1192             if(type == DisposeTypes.Explicit)
1193             {
1194                 //Called by User
1195                 //Release your own managed resources here.
1196                 //You should release all of your own disposable objects here.
1197             }
1198
1199             //Release your own unmanaged resources here.
1200             //You should not access any managed member here except static instance.
1201             //because the execution order of Finalizes is non-deterministic.
1202
1203             if (swigCPtr.Handle != global::System.IntPtr.Zero)
1204             {
1205                 if (swigCMemOwn)
1206                 {
1207                     swigCMemOwn = false;
1208                     NDalicPINVOKE.delete_Property_Value(swigCPtr);
1209                 }
1210                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1211             }
1212             disposed = true;
1213         }
1214
1215
1216         /// <summary>
1217         /// An extension to the property value class that allows us to create a
1218         /// Property value from a C# object, for example, integer, float, or string.<br />
1219         /// </summary>
1220         /// <param name="obj">An object to create.</param>
1221         /// <returns>The created value.</returns>
1222         /// <since_tizen> 3 </since_tizen>
1223         static public PropertyValue CreateFromObject(System.Object obj)
1224         {
1225             System.Type type = obj.GetType();
1226
1227             PropertyValue value;
1228
1229             if (type.Equals(typeof(int)))
1230             {
1231                 value = new PropertyValue((int)obj);
1232             }
1233             if (type.Equals(typeof(System.Int32)))
1234             {
1235                 value = new PropertyValue((int)obj);
1236             }
1237             else if (type.Equals(typeof(bool)))
1238             {
1239                 value = new PropertyValue((bool)obj);
1240             }
1241             else if (type.Equals(typeof(float)))
1242             {
1243                 value = new PropertyValue((float)obj);
1244             }
1245             else if (type.Equals(typeof(string)))
1246             {
1247                 value = new PropertyValue((string)obj);
1248             }
1249             else if (type.Equals(typeof(Vector2)))
1250             {
1251                 value = new PropertyValue((Vector2)obj);
1252             }
1253             else if (type.Equals(typeof(Vector3)))
1254             {
1255                 value = new PropertyValue((Vector3)obj);
1256             }
1257             else if (type.Equals(typeof(Vector4)))
1258             {
1259                 value = new PropertyValue((Vector4)obj);
1260             }
1261             else if (type.Equals(typeof(Position)))
1262             {
1263                 value = new PropertyValue((Position)obj);
1264             }
1265             else if (type.Equals(typeof(Position2D)))
1266             {
1267                 value = new PropertyValue((Position2D)obj);
1268             }
1269             else if (type.Equals(typeof(Size)))
1270             {
1271                 value = new PropertyValue((Size)obj);
1272             }
1273             else if (type.Equals(typeof(Size2D)))
1274             {
1275                 value = new PropertyValue((Size2D)obj);
1276             }
1277             else if (type.Equals(typeof(Color)))
1278             {
1279                 value = new PropertyValue((Color)obj);
1280             }
1281             else if (type.Equals(typeof(Rotation)))
1282             {
1283                 value = new PropertyValue((Rotation)obj);
1284             }
1285             else if (type.Equals(typeof(RelativeVector2)))
1286             {
1287                 value = new PropertyValue((RelativeVector2)obj);
1288             }
1289             else if (type.Equals(typeof(RelativeVector3)))
1290             {
1291                 value = new PropertyValue((RelativeVector3)obj);
1292             }
1293             else if (type.Equals(typeof(RelativeVector4)))
1294             {
1295                 value = new PropertyValue((RelativeVector4)obj);
1296             }
1297             else if(type.Equals(typeof(Extents)))
1298             {
1299                 value = new PropertyValue((Extents)obj);
1300             }
1301             else
1302             {
1303                 throw new global::System.InvalidOperationException("Unimplemented type for Property Value :" + type.Name);
1304             }
1305             NUILog.Debug(" got an property value of =" + type.Name);
1306             return value;
1307         }
1308
1309         /// <summary>
1310         /// Creates a Size2D property value.
1311         /// </summary>
1312         /// <param name="vectorValue">Size2D values.</param>
1313         /// <since_tizen> 3 </since_tizen>
1314         public PropertyValue(Size2D vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Size2D.getCPtr(vectorValue)), true)
1315         {
1316             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1317         }
1318
1319         /// <summary>
1320         /// Creates a Position2D property value.
1321         /// </summary>
1322         /// <param name="vectorValue">Position2D values.</param>
1323         /// <since_tizen> 3 </since_tizen>
1324         public PropertyValue(Position2D vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Position2D.getCPtr(vectorValue)), true)
1325         {
1326             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1327         }
1328
1329         /// <summary>
1330         /// Creates a Size property value.
1331         /// </summary>
1332         /// <param name="vectorValue">Size values.</param>
1333         internal PropertyValue(Size vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Size.getCPtr(vectorValue)), true)
1334         {
1335             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1336         }
1337
1338         /// <summary>
1339         /// Creates a Position property value.
1340         /// </summary>
1341         /// <param name="vectorValue">Position values.</param>
1342         /// <since_tizen> 3 </since_tizen>
1343         public PropertyValue(Position vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Position.getCPtr(vectorValue)), true)
1344         {
1345             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1346         }
1347
1348         /// <summary>
1349         /// Creates a Color property value.
1350         /// </summary>
1351         /// <param name="vectorValue">Color values.</param>
1352         /// <since_tizen> 3 </since_tizen>
1353         public PropertyValue(Color vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_6(Color.getCPtr(vectorValue)), true)
1354         {
1355             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1356         }
1357
1358
1359         /// <summary>
1360         /// Retrieves a Size2D value.
1361         /// </summary>
1362         /// <param name="vectorValue"> On return, a Size2D value.</param>
1363         /// <since_tizen> 3 </since_tizen>
1364         public bool Get(Size2D vectorValue)
1365         {
1366             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Size2D.getCPtr(vectorValue));
1367             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1368             return ret;
1369         }
1370
1371         /// <summary>
1372         /// Retrieves a Position2D value.
1373         /// </summary>
1374         /// <param name="vectorValue"> On return, a Position2D value.</param>
1375         /// <since_tizen> 3 </since_tizen>
1376         public bool Get(Position2D vectorValue)
1377         {
1378             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Position2D.getCPtr(vectorValue));
1379             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1380             return ret;
1381         }
1382
1383         /// <summary>
1384         /// Retrieves a Size value.
1385         /// </summary>
1386         /// <param name="vectorValue"> On return, a size value.</param>
1387         internal bool Get(Size vectorValue)
1388         {
1389             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Size.getCPtr(vectorValue));
1390             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1391             return ret;
1392         }
1393
1394         /// <summary>
1395         /// Retrieves a Position value.
1396         /// </summary>
1397         /// <param name="vectorValue"> On return, a position value.</param>
1398         /// <since_tizen> 3 </since_tizen>
1399         public bool Get(Position vectorValue)
1400         {
1401             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Position.getCPtr(vectorValue));
1402             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1403             return ret;
1404         }
1405
1406         /// <summary>
1407         /// Retrieves a Color value.
1408         /// </summary>
1409         /// <param name="vectorValue"> On return, a color value.</param>
1410         /// <since_tizen> 3 </since_tizen>
1411         public bool Get(Color vectorValue)
1412         {
1413             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_7(swigCPtr, Color.getCPtr(vectorValue));
1414             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1415             return ret;
1416         }
1417
1418
1419
1420         /// <summary>
1421         /// The default constructor.
1422         /// </summary>
1423         /// <since_tizen> 3 </since_tizen>
1424         public PropertyValue() : this(NDalicPINVOKE.new_Property_Value__SWIG_0(), true)
1425         {
1426             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1427         }
1428
1429         /// <summary>
1430         /// Creates a boolean property value.
1431         /// </summary>
1432         /// <param name="boolValue">A boolean value.</param>
1433         /// <since_tizen> 3 </since_tizen>
1434         public PropertyValue(bool boolValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_1(boolValue), true)
1435         {
1436             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1437         }
1438
1439         /// <summary>
1440         /// Creates an integer property value.
1441         /// </summary>
1442         /// <param name="integerValue">An integer value.</param>
1443         /// <since_tizen> 3 </since_tizen>
1444         public PropertyValue(int integerValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_2(integerValue), true)
1445         {
1446             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1447         }
1448
1449         /// <summary>
1450         /// Creates a float property value.
1451         /// </summary>
1452         /// <param name="floatValue">A floating-point value.</param>
1453         /// <since_tizen> 3 </since_tizen>
1454         public PropertyValue(float floatValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_3(floatValue), true)
1455         {
1456             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1457         }
1458
1459         /// <summary>
1460         /// Creates a Vector2 property value.
1461         /// </summary>
1462         /// <param name="vectorValue">A vector of 2 floating-point values.</param>
1463         /// <since_tizen> 3 </since_tizen>
1464         public PropertyValue(Vector2 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Vector2.getCPtr(vectorValue)), true)
1465         {
1466             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1467         }
1468
1469         /// <summary>
1470         /// Creates a Vector3 property value.
1471         /// </summary>
1472         /// <param name="vectorValue">A vector of 3 floating-point values.</param>
1473         /// <since_tizen> 3 </since_tizen>
1474         public PropertyValue(Vector3 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Vector3.getCPtr(vectorValue)), true)
1475         {
1476             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1477         }
1478
1479         /// <summary>
1480         /// Creates a Vector4 property value.
1481         /// </summary>
1482         /// <param name="vectorValue">A vector of 4 floating-point values.</param>
1483         /// <since_tizen> 3 </since_tizen>
1484         public PropertyValue(Vector4 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_6(Vector4.getCPtr(vectorValue)), true)
1485         {
1486             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1487         }
1488
1489         internal PropertyValue(Matrix3 matrixValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_7(Matrix3.getCPtr(matrixValue)), true)
1490         {
1491             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1492         }
1493
1494         internal PropertyValue(Matrix matrixValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_8(Matrix.getCPtr(matrixValue)), true)
1495         {
1496             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1497         }
1498
1499         /// <summary>
1500         /// Creates a Rectangle property value.
1501         /// </summary>
1502         /// <param name="vectorValue">Rectangle values.</param>
1503         /// <since_tizen> 3 </since_tizen>
1504         public PropertyValue(Rectangle vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_9(Rectangle.getCPtr(vectorValue)), true)
1505         {
1506             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1507         }
1508
1509         internal PropertyValue(AngleAxis angleAxis) : this(NDalicPINVOKE.new_Property_Value__SWIG_10(AngleAxis.getCPtr(angleAxis)), true)
1510         {
1511             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1512         }
1513
1514         /// <summary>
1515         /// Creates a Rotation property value.
1516         /// </summary>
1517         /// <param name="quaternion">Rotation values.</param>
1518         /// <since_tizen> 3 </since_tizen>
1519         public PropertyValue(Rotation quaternion) : this(NDalicPINVOKE.new_Property_Value__SWIG_11(Rotation.getCPtr(quaternion)), true)
1520         {
1521             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1522         }
1523
1524         /// <summary>
1525         /// Creates a string property value.
1526         /// </summary>
1527         /// <param name="stringValue">A string.</param>
1528         /// <since_tizen> 3 </since_tizen>
1529         public PropertyValue(string stringValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_12(stringValue), true)
1530         {
1531             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1532         }
1533
1534         /// <summary>
1535         /// Creates an array property value.
1536         /// </summary>
1537         /// <param name="arrayValue">An array.</param>
1538         /// <since_tizen> 3 </since_tizen>
1539         public PropertyValue(PropertyArray arrayValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_14(PropertyArray.getCPtr(arrayValue)), true)
1540         {
1541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1542         }
1543
1544         /// <summary>
1545         /// Creates a map property value.
1546         /// </summary>
1547         /// <param name="mapValue">An array.</param>
1548         /// <since_tizen> 3 </since_tizen>
1549         public PropertyValue(PropertyMap mapValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_15(PropertyMap.getCPtr(mapValue)), true)
1550         {
1551             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1552         }
1553
1554         /// <summary>
1555         /// Creates a Extents value.
1556         /// </summary>
1557         /// <param name="extentsValue">A Extents value.</param>
1558         /// <since_tizen> 4 </since_tizen>
1559         public PropertyValue(Extents extentsValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_16(Extents.getCPtr(extentsValue)), true)
1560         {
1561             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1562         }
1563
1564         /// <summary>
1565         /// Creates a PropertyType value.
1566         /// </summary>
1567         /// <param name="type">A PropertyType value.</param>
1568         /// <since_tizen> 3 </since_tizen>
1569         public PropertyValue(PropertyType type) : this(NDalicPINVOKE.new_Property_Value__SWIG_17((int)type), true)
1570         {
1571             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1572         }
1573
1574         /// <summary>
1575         /// Creates a PropertyValue value.
1576         /// </summary>
1577         /// <param name="value">A PropertyValue value.</param>
1578         /// <since_tizen> 3 </since_tizen>
1579         public PropertyValue(PropertyValue value) : this(NDalicPINVOKE.new_Property_Value__SWIG_18(PropertyValue.getCPtr(value)), true)
1580         {
1581             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1582         }
1583
1584         /// <summary>
1585         /// Queries the type of this property value.
1586         /// </summary>
1587         /// <returns>The type ID</returns>
1588         /// <since_tizen> 3 </since_tizen>
1589         public new PropertyType GetType()
1590         {
1591             PropertyType ret = (PropertyType)NDalicPINVOKE.Property_Value_GetType(swigCPtr);
1592             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1593             return ret;
1594         }
1595
1596         /// <summary>
1597         /// Retrieves a boolean value.
1598         /// </summary>
1599         /// <param name="boolValue">On return, a boolean value.</param>
1600         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1601         /// <since_tizen> 3 </since_tizen>
1602         public bool Get(out bool boolValue)
1603         {
1604             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_1(swigCPtr, out boolValue);
1605             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1606             return ret;
1607         }
1608
1609         /// <summary>
1610         /// Retrieves a floating-point value.
1611         /// </summary>
1612         /// <param name="floatValue">On return, a floating-point value.</param>
1613         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1614         /// <since_tizen> 3 </since_tizen>
1615         public bool Get(out float floatValue)
1616         {
1617             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_2(swigCPtr, out floatValue);
1618             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1619             return ret;
1620         }
1621
1622         /// <summary>
1623         /// Retrieves an integer value.
1624         /// </summary>
1625         /// <param name="integerValue">On return, an integer value.</param>
1626         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1627         /// <since_tizen> 3 </since_tizen>
1628         public bool Get(out int integerValue)
1629         {
1630             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_3(swigCPtr, out integerValue);
1631             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1632             return ret;
1633         }
1634
1635         /// <summary>
1636         /// Retrieves an integer rectangle.
1637         /// </summary>
1638         /// <param name="rect">On return, an integer rectangle.</param>
1639         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1640         /// <since_tizen> 3 </since_tizen>
1641         public bool Get(Rectangle rect)
1642         {
1643             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_4(swigCPtr, Rectangle.getCPtr(rect));
1644             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1645             return ret;
1646         }
1647
1648         /// <summary>
1649         /// Retrieves a vector value.
1650         /// </summary>
1651         /// <param name="vectorValue">On return, a vector value.</param>
1652         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1653         /// <since_tizen> 3 </since_tizen>
1654         public bool Get(Vector2 vectorValue)
1655         {
1656             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Vector2.getCPtr(vectorValue));
1657             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1658             return ret;
1659         }
1660
1661         /// <summary>
1662         /// Retrieves a vector value.
1663         /// </summary>
1664         /// <param name="vectorValue">On return, a vector value.</param>
1665         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1666         /// <since_tizen> 3 </since_tizen>
1667         public bool Get(Vector3 vectorValue)
1668         {
1669             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Vector3.getCPtr(vectorValue));
1670             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1671             return ret;
1672         }
1673
1674         /// <summary>
1675         /// Retrieves a vector value.
1676         /// </summary>
1677         /// <param name="vectorValue">On return, a vector value.</param>
1678         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1679         /// <since_tizen> 3 </since_tizen>
1680         public bool Get(Vector4 vectorValue)
1681         {
1682             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_7(swigCPtr, Vector4.getCPtr(vectorValue));
1683             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1684             return ret;
1685         }
1686
1687         internal bool Get(Matrix3 matrixValue)
1688         {
1689             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_8(swigCPtr, Matrix3.getCPtr(matrixValue));
1690             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1691             return ret;
1692         }
1693
1694         internal bool Get(Matrix matrixValue)
1695         {
1696             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_9(swigCPtr, Matrix.getCPtr(matrixValue));
1697             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1698             return ret;
1699         }
1700
1701         internal bool Get(AngleAxis angleAxisValue)
1702         {
1703             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_10(swigCPtr, AngleAxis.getCPtr(angleAxisValue));
1704             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1705             return ret;
1706         }
1707
1708         /// <summary>
1709         /// Retrieves a Rotation value.
1710         /// </summary>
1711         /// <param name="quaternionValue">On return, a rotation value.</param>
1712         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1713         /// <since_tizen> 3 </since_tizen>
1714         public bool Get(Rotation quaternionValue)
1715         {
1716             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_11(swigCPtr, Rotation.getCPtr(quaternionValue));
1717             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1718             return ret;
1719         }
1720
1721         /// <summary>
1722         /// Retrieves a string property value.
1723         /// </summary>
1724         /// <param name="stringValue">On return, a string.</param>
1725         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1726         /// <since_tizen> 3 </since_tizen>
1727         public bool Get(out string stringValue)
1728         {
1729             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_12(swigCPtr, out stringValue);
1730             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1731             return ret;
1732         }
1733
1734         /// <summary>
1735         /// Retrieves an array property value.
1736         /// </summary>
1737         /// <param name="arrayValue">On return, the array as a vector property values.</param>
1738         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1739         /// <since_tizen> 3 </since_tizen>
1740         public bool Get(PropertyArray arrayValue)
1741         {
1742             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_13(swigCPtr, PropertyArray.getCPtr(arrayValue));
1743             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1744             return ret;
1745         }
1746
1747         /// <summary>
1748         /// Retrieves a map property value.
1749         /// </summary>
1750         /// <param name="mapValue">On return, the map as vector of string and property value pairs.</param>
1751         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1752         /// <since_tizen> 3 </since_tizen>
1753         public bool Get(PropertyMap mapValue)
1754         {
1755             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_14(swigCPtr, PropertyMap.getCPtr(mapValue));
1756             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1757             return ret;
1758         }
1759
1760         /// <summary>
1761         /// Retrieves a Extents value.
1762         /// </summary>
1763         /// <param name="extentsValue">On return, a extents.</param>
1764         /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible.</returns>
1765         /// <since_tizen> 4 </since_tizen>
1766         public bool Get(Extents extentsValue)
1767         {
1768             bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_15(swigCPtr, Extents.getCPtr(extentsValue));
1769             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1770             return ret;
1771         }
1772     }
1773 }