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