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

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