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