src/Tizen.NUI/src/public/Position.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     /// <summary>
  24     /// Position is a three-dimensional vector.
  25     /// </summary>
  26     public class Position : global::System.IDisposable
  27     {
  28         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  29         /// <summary>
  30         /// swigCMemOwn
  31         /// </summary>
  32         /// <since_tizen> 3 </since_tizen>
  33         protected bool swigCMemOwn;
  34
  35         internal Position(global::System.IntPtr cPtr, bool cMemoryOwn)
  36         {
  37             swigCMemOwn = cMemoryOwn;
  38             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  39         }
  40
  41         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position obj)
  42         {
  43             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  44         }
  45
  46         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  47         private bool isDisposeQueued = false;
  48         /// <summary>
  49         /// A Flat to check if it is already disposed.
  50         /// </summary>
  51         /// <since_tizen> 3 </since_tizen>
  52         protected bool disposed = false;
  53
  54         /// <summary>
  55         /// Dispose.
  56         /// </summary>
  57         /// <since_tizen> 3 </since_tizen>
  58         ~Position()
  59         {
  60             if(!isDisposeQueued)
  61             {
  62                 isDisposeQueued = true;
  63                 DisposeQueue.Instance.Add(this);
  64             }
  65         }
  66
  67         /// <summary>
  68         /// Dispose.
  69         /// </summary>
  70         /// <since_tizen> 3 </since_tizen>
  71         public void Dispose()
  72         {
  73             //Throw excpetion if Dispose() is called in separate thread.
  74             if (!Window.IsInstalled())
  75             {
  76                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  77             }
  78
  79             if (isDisposeQueued)
  80             {
  81                 Dispose(DisposeTypes.Implicit);
  82             }
  83             else
  84             {
  85                 Dispose(DisposeTypes.Explicit);
  86                 System.GC.SuppressFinalize(this);
  87             }
  88         }
  89
  90         /// <summary>
  91         /// Dispose.
  92         /// </summary>
  93         /// <since_tizen> 3 </since_tizen>
  94         protected virtual void Dispose(DisposeTypes type)
  95         {
  96             if (disposed)
  97             {
  98                 return;
  99             }
 100
 101             if(type == DisposeTypes.Explicit)
 102             {
 103                 //Called by User
 104                 //Release your own managed resources here.
 105                 //You should release all of your own disposable objects here.
 106             }
 107
 108             //Release your own unmanaged resources here.
 109             //You should not access any managed member here except static instance.
 110             //because the execution order of Finalizes is non-deterministic.
 111
 112             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 113             {
 114                 if (swigCMemOwn)
 115                 {
 116                     swigCMemOwn = false;
 117                     NDalicPINVOKE.delete_Vector3(swigCPtr);
 118                 }
 119                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 120             }
 121             disposed = true;
 122         }
 123
 124
 125         /// <summary>
 126         /// An addition operator.
 127         /// </summary>
 128         /// <param name="arg1">The vector to add.</param>
 129         /// <param name="arg2">The vector to add.</param>
 130         /// <returns>The vector containing the result of the addition.</returns>
 131         /// <since_tizen> 3 </since_tizen>
 132         public static Position operator +(Position arg1, Position arg2)
 133         {
 134             return arg1.Add(arg2);
 135         }
 136
 137         /// <summary>
 138         /// The subtraction operator.
 139         /// </summary>
 140         /// <param name="arg1">The vector to subtract.</param>
 141         /// <param name="arg2">The vector to subtract.</param>
 142         /// <returns>The vector containing the result of the subtraction.</returns>
 143         /// <since_tizen> 3 </since_tizen>
 144         public static Position operator -(Position arg1, Position arg2)
 145         {
 146             return arg1.Subtract(arg2);
 147         }
 148
 149         /// <summary>
 150         /// The unary negation operator.
 151         /// </summary>
 152         /// <param name="arg1">The vector to negate.</param>
 153         /// <returns>The vector containg the negation.</returns>
 154         /// <since_tizen> 3 </since_tizen>
 155         public static Position operator -(Position arg1)
 156         {
 157             return arg1.Subtract();
 158         }
 159
 160         /// <summary>
 161         /// The multiplication operator.
 162         /// </summary>
 163         /// <param name="arg1">The vector to multiply.</param>
 164         /// <param name="arg2">The vector to multiply.</param>
 165         /// <returns>The vector containing the result of the multiplication.</returns>
 166         /// <since_tizen> 3 </since_tizen>
 167         public static Position operator *(Position arg1, Position arg2)
 168         {
 169             return arg1.Multiply(arg2);
 170         }
 171
 172         /// <summary>
 173         /// The multiplication operator.
 174         /// </summary>
 175         /// <param name="arg1">The vector to multiply</param>
 176         /// <param name="arg2">The float value to scale the vector.</param>
 177         /// <returns>The vector containing the result of scaling.</returns>
 178         /// <since_tizen> 3 </since_tizen>
 179         public static Position operator *(Position arg1, float arg2)
 180         {
 181             return arg1.Multiply(arg2);
 182         }
 183
 184         /// <summary>
 185         /// The division operator.
 186         /// </summary>
 187         /// <param name="arg1">The vector to divide.</param>
 188         /// <param name="arg2">The vector to divide.</param>
 189         /// <returns>The vector containing the result of the division.</returns>
 190         /// <since_tizen> 3 </since_tizen>
 191         public static Position operator /(Position arg1, Position arg2)
 192         {
 193             return arg1.Divide(arg2);
 194         }
 195
 196         /// <summary>
 197         /// The division operator.
 198         /// </summary>
 199         /// <param name="arg1">The vector to divide.</param>
 200         /// <param name="arg2">The float value to scale the vector by.</param>
 201         /// <returns>The vector containing the result of scaling.</returns>
 202         /// <since_tizen> 3 </since_tizen>
 203         public static Position operator /(Position arg1, float arg2)
 204         {
 205             return arg1.Divide(arg2);
 206         }
 207
 208
 209         /// <summary>
 210         /// The const array subscript operator overload. Should be 0, 1, or 2.
 211         /// </summary>
 212         /// <param name="index">The subscript index.</param>
 213         /// <returns>The float at the given index.</returns>
 214         /// <since_tizen> 3 </since_tizen>
 215         public float this[uint index]
 216         {
 217             get
 218             {
 219                 return ValueOfIndex(index);
 220             }
 221         }
 222
 223         internal static Position GetPositionFromPtr(global::System.IntPtr cPtr)
 224         {
 225             Position ret = new Position(cPtr, false);
 226             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 227             return ret;
 228         }
 229
 230
 231         /// <summary>
 232         /// The constructor.
 233         /// </summary>
 234         /// <since_tizen> 3 </since_tizen>
 235         public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true)
 236         {
 237             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 238         }
 239
 240         /// <summary>
 241         /// The constructor.
 242         /// </summary>
 243         /// <param name="x">The x component.</param>
 244         /// <param name="y">The y component.</param>
 245         /// <param name="z">The z component.</param>
 246         /// <since_tizen> 3 </since_tizen>
 247         public Position(float x, float y, float z) : this(NDalicPINVOKE.new_Vector3__SWIG_1(x, y, z), true)
 248         {
 249             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 250         }
 251
 252         /// <summary>
 253         /// The constructor.
 254         /// </summary>
 255         /// <param name="position2d">Position2D to create this vector from.</param>
 256         /// <since_tizen> 3 </since_tizen>
 257         public Position(Position2D position2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true)
 258         {
 259             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 260         }
 261
 262
 263
 264         private Position Add(Position rhs)
 265         {
 266             Position ret = new Position(NDalicPINVOKE.Vector3_Add(swigCPtr, Position.getCPtr(rhs)), true);
 267             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 268             return ret;
 269         }
 270
 271         private Position Subtract(Position rhs)
 272         {
 273             Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 274             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 275             return ret;
 276         }
 277
 278         private Position Multiply(Position rhs)
 279         {
 280             Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 281             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 282             return ret;
 283         }
 284
 285         private Position Multiply(float rhs)
 286         {
 287             Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_1(swigCPtr, rhs), true);
 288             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 289             return ret;
 290         }
 291
 292         private Position Divide(Position rhs)
 293         {
 294             Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 295             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 296             return ret;
 297         }
 298
 299         private Position Divide(float rhs)
 300         {
 301             Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_1(swigCPtr, rhs), true);
 302             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 303             return ret;
 304         }
 305
 306         private Position Subtract()
 307         {
 308             Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_1(swigCPtr), true);
 309             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 310             return ret;
 311         }
 312
 313         private float ValueOfIndex(uint index)
 314         {
 315             float ret = NDalicPINVOKE.Vector3_ValueOfIndex__SWIG_0(swigCPtr, index);
 316             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 317             return ret;
 318         }
 319
 320         /// <summary>
 321         /// Compares if rhs is equal to.
 322         /// </summary>
 323         /// <param name="rhs">The vector to compare.</param>
 324         /// <returns>Returns true if the two vectors are equal, otherwise false.</returns>
 325         /// <since_tizen> 3 </since_tizen>
 326         public bool EqualTo(Position rhs)
 327         {
 328             bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
 329             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 330             return ret;
 331         }
 332
 333         /// <summary>
 334         /// Compares if rhs is not equal to.
 335         /// </summary>
 336         /// <param name="rhs">The vector to compare.</param>
 337         /// <returns>Returns true if the two vectors are not equal, otherwise false.</returns>
 338         /// <since_tizen> 3 </since_tizen>
 339         public bool NotEqualTo(Position rhs)
 340         {
 341             bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
 342             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 343             return ret;
 344         }
 345
 346
 347         /// <summary>
 348         /// The x component.
 349         /// </summary>
 350         /// <since_tizen> 3 </since_tizen>
 351         public float X
 352         {
 353             set
 354             {
 355                 NDalicPINVOKE.Vector3_X_set(swigCPtr, value);
 356                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 357             }
 358             get
 359             {
 360                 float ret = NDalicPINVOKE.Vector3_X_get(swigCPtr);
 361                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 362                 return ret;
 363             }
 364         }
 365
 366         /// <summary>
 367         /// The y component.
 368         /// </summary>
 369         /// <since_tizen> 3 </since_tizen>
 370         public float Y
 371         {
 372             set
 373             {
 374                 NDalicPINVOKE.Vector3_Y_set(swigCPtr, value);
 375                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376             }
 377             get
 378             {
 379                 float ret = NDalicPINVOKE.Vector3_Y_get(swigCPtr);
 380                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 381                 return ret;
 382             }
 383         }
 384
 385         /// <summary>
 386         /// The z component.
 387         /// </summary>
 388         /// <since_tizen> 3 </since_tizen>
 389         public float Z
 390         {
 391             set
 392             {
 393                 NDalicPINVOKE.Vector3_Z_set(swigCPtr, value);
 394                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 395             }
 396             get
 397             {
 398                 float ret = NDalicPINVOKE.Vector3_Z_get(swigCPtr);
 399                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 400                 return ret;
 401             }
 402         }
 403
 404         /// <summary>
 405         /// ParentOrigin constants. It's 0.0.
 406         /// </summary>
 407         /// <since_tizen> 3 </since_tizen>
 408         public static float ParentOriginTop
 409         {
 410             get
 411             {
 412                 float ret = NDalicPINVOKE.ParentOriginTop_get();
 413                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 414                 return ret;
 415             }
 416         }
 417
 418         /// <summary>
 419         /// ParentOrigin constants. It's 1.0.
 420         /// </summary>
 421         /// <since_tizen> 3 </since_tizen>
 422         public static float ParentOriginBottom
 423         {
 424             get
 425             {
 426                 float ret = NDalicPINVOKE.ParentOriginBottom_get();
 427                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 428                 return ret;
 429             }
 430         }
 431
 432         /// <summary>
 433         /// ParentOrigin constants. It's 0.0.
 434         /// </summary>
 435         /// <since_tizen> 3 </since_tizen>
 436         public static float ParentOriginLeft
 437         {
 438             get
 439             {
 440                 float ret = NDalicPINVOKE.ParentOriginLeft_get();
 441                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 442                 return ret;
 443             }
 444         }
 445
 446         /// <summary>
 447         /// ParentOrigin constants. It's 1.0.
 448         /// </summary>
 449         /// <since_tizen> 3 </since_tizen>
 450         public static float ParentOriginRight
 451         {
 452             get
 453             {
 454                 float ret = NDalicPINVOKE.ParentOriginRight_get();
 455                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 456                 return ret;
 457             }
 458         }
 459
 460         /// <summary>
 461         /// ParentOrigin constants. It's 0.5.
 462         /// </summary>
 463         /// <since_tizen> 3 </since_tizen>
 464         public static float ParentOriginMiddle
 465         {
 466             get
 467             {
 468                 float ret = NDalicPINVOKE.ParentOriginMiddle_get();
 469                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470                 return ret;
 471             }
 472         }
 473
 474         /// <summary>
 475         /// ParentOrigin constants: 0.0, 0.0, 0.5.
 476         /// </summary>
 477         /// <since_tizen> 3 </since_tizen>
 478         public static Position ParentOriginTopLeft
 479         {
 480             get
 481             {
 482                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopLeft_get();
 483                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 484                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 485                 return ret;
 486             }
 487         }
 488
 489         /// <summary>
 490         /// ParentOrigin constants: 0.5, 0.0, 0.5.
 491         /// </summary>
 492         /// <since_tizen> 3 </since_tizen>
 493         public static Position ParentOriginTopCenter
 494         {
 495             get
 496             {
 497                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopCenter_get();
 498                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 499                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 500                 return ret;
 501             }
 502         }
 503
 504         /// <summary>
 505         /// ParentOrigin constants: 1.0, 0.0, 0.5.
 506         /// </summary>
 507         /// <since_tizen> 3 </since_tizen>
 508         public static Position ParentOriginTopRight
 509         {
 510             get
 511             {
 512                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopRight_get();
 513                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 514                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 515                 return ret;
 516             }
 517         }
 518
 519         /// <summary>
 520         /// ParentOrigin constants: 0.0, 0.5, 0.5.
 521         /// </summary>
 522         /// <since_tizen> 3 </since_tizen>
 523         public static Position ParentOriginCenterLeft
 524         {
 525             get
 526             {
 527                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterLeft_get();
 528                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 529                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 530                 return ret;
 531             }
 532         }
 533
 534         /// <summary>
 535         /// ParentOrigin constants: 0.0, 0.5, 0.5
 536         /// </summary>
 537         /// <since_tizen> 3 </since_tizen>
 538         public static Position ParentOriginCenter
 539         {
 540             get
 541             {
 542                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenter_get();
 543                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 544                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 545                 return ret;
 546             }
 547         }
 548
 549         /// <summary>
 550         /// ParentOrigin constants: 1.0, 0.5, 0.5.
 551         /// </summary>
 552         /// <since_tizen> 3 </since_tizen>
 553         public static Position ParentOriginCenterRight
 554         {
 555             get
 556             {
 557                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterRight_get();
 558                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 559                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 560                 return ret;
 561             }
 562         }
 563
 564         /// <summary>
 565         /// ParentOrigin constants: 0.0f, 1.0f, 0.5f.
 566         /// </summary>
 567         /// <since_tizen> 3 </since_tizen>
 568         public static Position ParentOriginBottomLeft
 569         {
 570             get
 571             {
 572                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomLeft_get();
 573                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 574                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 575                 return ret;
 576             }
 577         }
 578
 579         /// <summary>
 580         /// ParentOrigin constants: 0.5, 1.0, 0.5.
 581         /// </summary>
 582         /// <since_tizen> 3 </since_tizen>
 583         public static Position ParentOriginBottomCenter
 584         {
 585             get
 586             {
 587                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomCenter_get();
 588                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 589                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 590                 return ret;
 591             }
 592         }
 593
 594         /// <summary>
 595         /// ParentOrigin constants: 1.0, 1.0, 0.5.
 596         /// </summary>
 597         /// <since_tizen> 3 </since_tizen>
 598         public static Position ParentOriginBottomRight
 599         {
 600             get
 601             {
 602                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomRight_get();
 603                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 604                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 605                 return ret;
 606             }
 607         }
 608
 609         /// <summary>
 610         /// PivotPoint constants: 0.0.
 611         /// </summary>
 612         /// <since_tizen> 4 </since_tizen>
 613         public static float PivotPointTop
 614         {
 615             get
 616             {
 617                 float ret = NDalicPINVOKE.AnchorPointTop_get();
 618                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 619                 return ret;
 620             }
 621         }
 622
 623         /// <summary>
 624         /// PivotPoint constants: 1.0.
 625         /// </summary>
 626         /// <since_tizen> 4 </since_tizen>
 627         public static float PivotPointBottom
 628         {
 629             get
 630             {
 631                 float ret = NDalicPINVOKE.AnchorPointBottom_get();
 632                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 633                 return ret;
 634             }
 635         }
 636
 637         /// <summary>
 638         /// PivotPoint constants: 0.0.
 639         /// </summary>
 640         /// <since_tizen> 4 </since_tizen>
 641         public static float PivotPointLeft
 642         {
 643             get
 644             {
 645                 float ret = NDalicPINVOKE.AnchorPointLeft_get();
 646                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 647                 return ret;
 648             }
 649         }
 650
 651         /// <summary>
 652         /// PivotPoint constants: 1.0.
 653         /// </summary>
 654         /// <since_tizen> 4 </since_tizen>
 655         public static float PivotPointRight
 656         {
 657             get
 658             {
 659                 float ret = NDalicPINVOKE.AnchorPointRight_get();
 660                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 661                 return ret;
 662             }
 663         }
 664
 665         /// <summary>
 666         /// PivotPoint constants: 0.0.
 667         /// </summary>
 668         /// <since_tizen> 4 </since_tizen>
 669         public static float PivotPointMiddle
 670         {
 671             get
 672             {
 673                 float ret = NDalicPINVOKE.AnchorPointMiddle_get();
 674                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 675                 return ret;
 676             }
 677         }
 678
 679         /// <summary>
 680         /// PivotPoint constants: 0.0, 0.0, 0.5.
 681         /// </summary>
 682         /// <since_tizen> 4 </since_tizen>
 683         public static Position PivotPointTopLeft
 684         {
 685             get
 686             {
 687                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
 688                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 689                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 690                 return ret;
 691             }
 692         }
 693
 694         /// <summary>
 695         /// PivotPoint constants: 0.5, 0.0, 0.5.
 696         /// </summary>
 697         /// <since_tizen> 4 </since_tizen>
 698         public static Position PivotPointTopCenter
 699         {
 700             get
 701             {
 702                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
 703                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 704                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 705                 return ret;
 706             }
 707         }
 708
 709         /// <summary>
 710         /// PivotPoint constants: 1.0, 0.0, 0.5.
 711         /// </summary>
 712         /// <since_tizen> 4 </since_tizen>
 713         public static Position PivotPointTopRight
 714         {
 715             get
 716             {
 717                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
 718                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 719                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 720                 return ret;
 721             }
 722         }
 723
 724         /// <summary>
 725         /// PivotPoint constants: 0.0, 0.5, 0.5.
 726         /// </summary>
 727         /// <since_tizen> 4 </since_tizen>
 728         public static Position PivotPointCenterLeft
 729         {
 730             get
 731             {
 732                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
 733                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 734                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 735                 return ret;
 736             }
 737         }
 738
 739         /// <summary>
 740         /// PivotPoint constants: 0.5, 0.5, 0.5.
 741         /// </summary>
 742         /// <since_tizen> 4 </since_tizen>
 743         public static Position PivotPointCenter
 744         {
 745             get
 746             {
 747                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
 748                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 749                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 750                 return ret;
 751             }
 752         }
 753
 754         /// <summary>
 755         /// PivotPoint constants: 1.0, 0.5, 0.5.
 756         /// </summary>
 757         /// <since_tizen> 4 </since_tizen>
 758         public static Position PivotPointCenterRight
 759         {
 760             get
 761             {
 762                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
 763                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 764                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 765                 return ret;
 766             }
 767         }
 768
 769         /// <summary>
 770         /// PivotPoint constants: 0.0, 1.0, 0.5.
 771         /// </summary>
 772         /// <since_tizen> 4 </since_tizen>
 773         public static Position PivotPointBottomLeft
 774         {
 775             get
 776             {
 777                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
 778                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 779                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 780                 return ret;
 781             }
 782         }
 783
 784         /// <summary>
 785         /// PivotPoint constants: 0.5, 1.0, 0.5
 786         /// </summary>
 787         /// <since_tizen> 4 </since_tizen>
 788         public static Position PivotPointBottomCenter
 789         {
 790             get
 791             {
 792                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
 793                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 794                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 795                 return ret;
 796             }
 797         }
 798
 799         /// <summary>
 800         /// PivotPoint constants: 1.0, 1.0, 0.5.
 801         /// </summary>
 802         /// <since_tizen> 4 </since_tizen>
 803         public static Position PivotPointBottomRight
 804         {
 805             get
 806             {
 807                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_get();
 808                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 809                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 810                 return ret;
 811             }
 812         }
 813
 814         /// <summary>
 815         /// Constant ( 1.0f, 1.0f, 1.0f ).
 816         /// </summary>
 817         /// <since_tizen> 3 </since_tizen>
 818         public static Position One
 819         {
 820             get
 821             {
 822                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ONE_get();
 823                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 824                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 825                 return ret;
 826             }
 827         }
 828
 829         internal static Position XAxis
 830         {
 831             get
 832             {
 833                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_XAXIS_get();
 834                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 835                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 836                 return ret;
 837             }
 838         }
 839
 840         internal static Position YAxis
 841         {
 842             get
 843             {
 844                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_YAXIS_get();
 845                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 846                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 847                 return ret;
 848             }
 849         }
 850
 851         internal static Position ZAxis
 852         {
 853             get
 854             {
 855                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZAXIS_get();
 856                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 857                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 858                 return ret;
 859             }
 860         }
 861
 862         internal static Position NegativeXAxis
 863         {
 864             get
 865             {
 866                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_XAXIS_get();
 867                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 868                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 869                 return ret;
 870             }
 871         }
 872
 873         internal static Position NegativeYAxis
 874         {
 875             get
 876             {
 877                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_YAXIS_get();
 878                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 879                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 880                 return ret;
 881             }
 882         }
 883
 884         internal static Position NegativeZAxis
 885         {
 886             get
 887             {
 888                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_ZAXIS_get();
 889                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 890                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 891                 return ret;
 892             }
 893         }
 894
 895         /// <summary>
 896         /// Constant ( 0.0f, 0.0f, 0.0f ).
 897         /// </summary>
 898         /// <since_tizen> 3 </since_tizen>
 899         public static Position Zero
 900         {
 901             get
 902             {
 903                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZERO_get();
 904                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 905                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 906                 return ret;
 907             }
 908         }
 909
 910         /// <summary>
 911         /// Converts a position instance to a Vector3 instance.
 912         /// </summary>
 913         /// <since_tizen> 3 </since_tizen>
 914         public static implicit operator Vector3(Position Position)
 915         {
 916             return new Vector3(Position.X, Position.Y, Position.Z);
 917         }
 918
 919         /// <summary>
 920         /// Converts a Vector3 instance to a position instance.
 921         /// </summary>
 922         /// <since_tizen> 3 </since_tizen>
 923         public static implicit operator Position(Vector3 vec)
 924         {
 925             return new Position(vec.X, vec.Y, vec.Z);
 926         }
 927
 928         /// <summary>
 929         /// [Obsolete("Please do not use! this will be deprecated")]
 930         /// </summary>
 931         /// <since_tizen> 3 </since_tizen>
 932         [Obsolete("Please do not use! this will be deprecated")]
 933         public static float AnchorPointTop
 934         {
 935             get
 936             {
 937                 float ret = NDalicPINVOKE.AnchorPointTop_get();
 938                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 939                 return ret;
 940             }
 941         }
 942
 943         /// <summary>
 944         /// [Obsolete("Please do not use! this will be deprecated")]
 945         /// </summary>
 946         /// <since_tizen> 3 </since_tizen>
 947         [Obsolete("Please do not use! this will be deprecated")]
 948         public static float AnchorPointBottom
 949         {
 950             get
 951             {
 952                 float ret = NDalicPINVOKE.AnchorPointBottom_get();
 953                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 954                 return ret;
 955             }
 956         }
 957
 958         /// <summary>
 959         /// [Obsolete("Please do not use! this will be deprecated")]
 960         /// </summary>
 961         /// <since_tizen> 3 </since_tizen>
 962         [Obsolete("Please do not use! this will be deprecated")]
 963         public static float AnchorPointLeft
 964         {
 965             get
 966             {
 967                 float ret = NDalicPINVOKE.AnchorPointLeft_get();
 968                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 969                 return ret;
 970             }
 971         }
 972
 973         /// <summary>
 974         /// [Obsolete("Please do not use! this will be deprecated")]
 975         /// </summary>
 976         /// <since_tizen> 3 </since_tizen>
 977         [Obsolete("Please do not use! this will be deprecated")]
 978         public static float AnchorPointRight
 979         {
 980             get
 981             {
 982                 float ret = NDalicPINVOKE.AnchorPointRight_get();
 983                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 984                 return ret;
 985             }
 986         }
 987
 988         /// <summary>
 989         /// [Obsolete("Please do not use! this will be deprecated")]
 990         /// </summary>
 991         /// <since_tizen> 3 </since_tizen>
 992         [Obsolete("Please do not use! this will be deprecated")]
 993         public static float AnchorPointMiddle
 994         {
 995             get
 996             {
 997                 float ret = NDalicPINVOKE.AnchorPointMiddle_get();
 998                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 999                 return ret;
1000             }
1001         }
1002
1003         /// <summary>
1004         /// [Obsolete("Please do not use! this will be deprecated")]
1005         /// </summary>
1006         /// <since_tizen> 3 </since_tizen>
1007         [Obsolete("Please do not use! this will be deprecated")]
1008         public static Position AnchorPointTopLeft
1009         {
1010             get
1011             {
1012                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
1013                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1014                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1015                 return ret;
1016             }
1017         }
1018
1019         /// <summary>
1020         /// [Obsolete("Please do not use! this will be deprecated")]
1021         /// </summary>
1022         /// <since_tizen> 3 </since_tizen>
1023         [Obsolete("Please do not use! this will be deprecated")]
1024         public static Position AnchorPointTopCenter
1025         {
1026             get
1027             {
1028                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
1029                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1030                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1031                 return ret;
1032             }
1033         }
1034
1035         /// <summary>
1036         /// [Obsolete("Please do not use! this will be deprecated")]
1037         /// </summary>
1038         /// <since_tizen> 3 </since_tizen>
1039         [Obsolete("Please do not use! this will be deprecated")]
1040         public static Position AnchorPointTopRight
1041         {
1042             get
1043             {
1044                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
1045                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1046                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1047                 return ret;
1048             }
1049         }
1050
1051         /// <summary>
1052         /// [Obsolete("Please do not use! this will be deprecated")]
1053         /// </summary>
1054         /// <since_tizen> 3 </since_tizen>
1055         [Obsolete("Please do not use! this will be deprecated")]
1056         public static Position AnchorPointCenterLeft
1057         {
1058             get
1059             {
1060                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
1061                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1062                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1063                 return ret;
1064             }
1065         }
1066
1067         /// <summary>
1068         /// [Obsolete("Please do not use! this will be deprecated")]
1069         /// </summary>
1070         /// <since_tizen> 3 </since_tizen>
1071         [Obsolete("Please do not use! this will be deprecated")]
1072         public static Position AnchorPointCenter
1073         {
1074             get
1075             {
1076                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
1077                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1078                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1079                 return ret;
1080             }
1081         }
1082
1083         /// <summary>
1084         /// [Obsolete("Please do not use! this will be deprecated")]
1085         /// </summary>
1086         /// <since_tizen> 3 </since_tizen>
1087         [Obsolete("Please do not use! this will be deprecated")]
1088         public static Position AnchorPointCenterRight
1089         {
1090             get
1091             {
1092                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
1093                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1094                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1095                 return ret;
1096             }
1097         }
1098
1099         /// <summary>
1100         /// [Obsolete("Please do not use! this will be deprecated")]
1101         /// </summary>
1102         /// <since_tizen> 3 </since_tizen>
1103         [Obsolete("Please do not use! this will be deprecated")]
1104         public static Position AnchorPointBottomLeft
1105         {
1106             get
1107             {
1108                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
1109                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1110                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1111                 return ret;
1112             }
1113         }
1114
1115         /// <summary>
1116         /// [Obsolete("Please do not use! this will be deprecated")]
1117         /// </summary>
1118         /// <since_tizen> 3 </since_tizen>
1119         [Obsolete("Please do not use! this will be deprecated")]
1120         public static Position AnchorPointBottomCenter
1121         {
1122             get
1123             {
1124                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
1125                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1126                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1127                 return ret;
1128             }
1129         }
1130
1131         /// <summary>
1132         /// [Obsolete("Please do not use! this will be deprecated")]
1133         /// </summary>
1134         /// <since_tizen> 3 </since_tizen>
1135         [Obsolete("Please do not use! this will be deprecated")]
1136         public static Position AnchorPointBottomRight
1137         {
1138             get
1139             {
1140                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_get();
1141                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1142                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1143                 return ret;
1144             }
1145         }
1146
1147     }
1148 }