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