src/Tizen.NUI/src/public/Position.cs

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