src/Tizen.NUI/src/public/Layer.cs

   1 /*
   2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using Tizen.NUI.BaseComponents;
  19 using System.ComponentModel;
  20
  21 namespace Tizen.NUI
  22 {
  23
  24     /// <summary>
  25     /// Layers provide a mechanism for overlaying groups of actors on top of each other.
  26     /// </summary>
  27     /// <since_tizen> 3 </since_tizen>
  28     public class Layer : Container
  29     {
  30         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  31
  32         internal Layer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Layer_SWIGUpcast(cPtr), cMemoryOwn)
  33         {
  34             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  35         }
  36
  37         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Layer obj)
  38         {
  39             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  40         }
  41
  42         /// From the Container base class.
  43
  44         /// <summary>
  45         /// Adds a child view to this layer.
  46         /// </summary>
  47         /// <seealso cref="Container.Add">
  48         /// </seealso>
  49         /// <since_tizen> 4 </since_tizen>
  50         public override void Add(View child)
  51         {
  52             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
  53             if (NDalicPINVOKE.SWIGPendingException.Pending)
  54                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  55
  56             Children.Add(child);
  57         }
  58
  59         /// <summary>
  60         /// Removes a child view from this layer. If the view was not a child of this layer, this is a no-op.
  61         /// </summary>
  62         /// <seealso cref="Container.Remove">
  63         /// </seealso>
  64         /// <since_tizen> 4 </since_tizen>
  65         public override void Remove(View child)
  66         {
  67             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
  68             if (NDalicPINVOKE.SWIGPendingException.Pending)
  69                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  70
  71             Children.Remove(child);
  72         }
  73
  74         /// <summary>
  75         /// Retrieves a child view by the index.
  76         /// </summary>
  77         /// <pre>The view has been initialized.</pre>
  78         /// <param name="index">The index of the child to retrieve.</param>
  79         /// <returns>The view for the given index or empty handle if children not initialized.</returns>
  80         /// <since_tizen> 4 </since_tizen>
  81         public override View GetChildAt(uint index)
  82         {
  83             if (index < Children.Count)
  84             {
  85                 return Children[Convert.ToInt32(index)];
  86             }
  87             else
  88             {
  89                 return null;
  90             }
  91         }
  92
  93
  94         /// <summary>
  95         /// Get parent of the layer.
  96         /// </summary>
  97         /// <returns>The view's container</returns>
  98         /// <since_tizen> 4 </since_tizen>
  99         public override Container GetParent()
 100         {
 101             return null;
 102         }
 103
 104         /// <summary>
 105         /// Get the child count of the layer.
 106         /// </summary>
 107         /// <returns>The child count of the layer.</returns>
 108         /// <since_tizen> 4 </since_tizen>
 109         public override uint GetChildCount()
 110         {
 111             return Convert.ToUInt32(Children.Count);
 112         }
 113
 114         /// <summary>
 115         /// Dispose.
 116         /// </summary>
 117         /// <since_tizen> 3 </since_tizen>
 118         protected override void Dispose(DisposeTypes type)
 119         {
 120             if(disposed)
 121             {
 122                 return;
 123             }
 124
 125             if(type == DisposeTypes.Explicit)
 126             {
 127                 //Called by User
 128                 //Release your own managed resources here.
 129                 //You should release all of your own disposable objects here.
 130             }
 131
 132             //Release your own unmanaged resources here.
 133             //You should not access any managed member here except static instance.
 134             //because the execution order of Finalizes is non-deterministic.
 135
 136             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 137             {
 138                 if (swigCMemOwn)
 139                 {
 140                     swigCMemOwn = false;
 141                     NDalicPINVOKE.delete_Layer(swigCPtr);
 142                 }
 143                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 144             }
 145
 146             base.Dispose(type);
 147
 148         }
 149
 150
 151         internal class Property
 152         {
 153             internal static readonly int BEHAVIOR = NDalicPINVOKE.Layer_Property_BEHAVIOR_get();
 154         }
 155
 156         /// <summary>
 157         /// Creates a Layer object.
 158         /// </summary>
 159         /// <since_tizen> 3 </since_tizen>
 160         public Layer() : this(NDalicPINVOKE.Layer_New(), true)
 161         {
 162             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 163             if(Window.Instance != null)
 164             {
 165                 this.SetAnchorPoint(Tizen.NUI.PivotPoint.TopLeft);
 166                 this.SetResizePolicy(ResizePolicyType.FillToParent, DimensionType.AllDimensions);
 167             }
 168         }
 169         internal void SetAnchorPoint(Vector3 anchorPoint)
 170         {
 171             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
 172             if (NDalicPINVOKE.SWIGPendingException.Pending)
 173                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 174         }
 175         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
 176         {
 177             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
 178             if (NDalicPINVOKE.SWIGPendingException.Pending)
 179                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 180         }
 181
 182         /// <summary>
 183         /// Downcasts a handle to layer handle.
 184         /// </summary>
 185         /// <since_tizen> 3 </since_tizen>
 186         /// Please do not use! this will be deprecated!
 187         /// Instead please use as keyword.
 188         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead!")]
 189         [EditorBrowsable(EditorBrowsableState.Never)]
 190         public static Layer DownCast(BaseHandle handle)
 191         {
 192             Layer ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as Layer;
 193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 194             return ret;
 195         }
 196
 197         /// <summary>
 198         /// Search through this layer's hierarchy for a view with the given unique ID.
 199         /// </summary>
 200         /// <pre>This layer (the parent) has been initialized.</pre>
 201         /// <remarks>The actor itself is also considered in the search.</remarks>
 202         /// <param name="id">The id of the child to find</param>
 203         /// <returns> A handle to the view if found, or an empty handle if not. </returns>
 204         /// <since_tizen> 3 </since_tizen>
 205         public View FindChildById(uint id)
 206         {
 207             IntPtr cPtr = NDalicPINVOKE.Actor_FindChildById(swigCPtr, id);
 208             View ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as View;
 209
 210             if (NDalicPINVOKE.SWIGPendingException.Pending)
 211                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 212             return ret;
 213         }
 214
 215         /// <summary>
 216         /// Queries the depth of the layer.<br />
 217         /// 0 is the bottommost layer, higher number is on the top.<br />
 218         /// </summary>
 219         /// <since_tizen> 3 </since_tizen>
 220         public uint Depth
 221         {
 222             get
 223             {
 224                 return GetDepth();
 225             }
 226         }
 227
 228         internal uint GetDepth()
 229         {
 230             var parentChildren = Window.Instance.LayersChildren;
 231             if(parentChildren != null)
 232             {
 233                 int idx = parentChildren.IndexOf(this);
 234                 if (idx >= 0)
 235                 {
 236                     return Convert.ToUInt32(idx); ;
 237                 }
 238             }
 239             return 0u;
 240         }
 241
 242         /// <summary>
 243         /// Increments the depth of the layer.
 244         /// </summary>
 245         /// <since_tizen> 3 </since_tizen>
 246         public void Raise()
 247         {
 248             var parentChildren = Window.Instance.LayersChildren;
 249             if (parentChildren != null)
 250             {
 251                 int currentIdx = parentChildren.IndexOf(this);
 252
 253                 if (currentIdx != parentChildren.Count - 1)
 254                 {
 255                     RaiseAbove(parentChildren[currentIdx + 1]);
 256
 257                     Layer temp = parentChildren[currentIdx + 1];
 258                     parentChildren[currentIdx + 1] = this;
 259                     parentChildren[currentIdx] = temp;
 260                 }
 261             }
 262             NDalicPINVOKE.Layer_Raise(swigCPtr);
 263             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 264         }
 265
 266         /// <summary>
 267         /// Decrements the depth of the layer.
 268         /// </summary>
 269         /// <since_tizen> 3 </since_tizen>
 270         public void Lower()
 271         {
 272             var parentChildren = Window.Instance.LayersChildren;
 273             if (parentChildren != null)
 274             {
 275                 int currentIdx = parentChildren.IndexOf(this);
 276
 277                 if (currentIdx > 0)
 278                 {
 279                     LowerBelow(parentChildren[currentIdx - 1]);
 280
 281                     Layer temp = parentChildren[currentIdx - 1];
 282                     parentChildren[currentIdx - 1] = this;
 283                     parentChildren[currentIdx] = temp;
 284
 285                 }
 286             }
 287             NDalicPINVOKE.Layer_Lower(swigCPtr);
 288             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 289         }
 290
 291         internal void RaiseAbove(Layer target)
 292         {
 293             var parentChildren = Window.Instance.LayersChildren;
 294             if (parentChildren != null)
 295             {
 296                 int currentIndex = parentChildren.IndexOf(this);
 297                 int targetIndex = parentChildren.IndexOf(target);
 298
 299                 // If the currentIndex is less than the target index and the target has the same parent.
 300                 if (currentIndex < targetIndex)
 301                 {
 302                     parentChildren.Remove(this);
 303                     parentChildren.Insert(targetIndex, this);
 304                 }
 305             }
 306             NDalicPINVOKE.Layer_RaiseAbove(swigCPtr, Layer.getCPtr(target));
 307             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 308         }
 309
 310         internal void LowerBelow(Layer target)
 311         {
 312             var parentChildren = Window.Instance.LayersChildren;
 313
 314             if (parentChildren != null)
 315             {
 316                 int currentIndex = parentChildren.IndexOf(this);
 317                 int targetIndex = parentChildren.IndexOf(target);
 318
 319                 // If the currentIndex is not already the 0th index and the target has the same parent.
 320                 if ((currentIndex != 0) && (targetIndex != -1) &&
 321                     (currentIndex > targetIndex))
 322                 {
 323                     parentChildren.Remove(this);
 324                     parentChildren.Insert(targetIndex, this);
 325                 }
 326             }
 327             NDalicPINVOKE.Layer_LowerBelow(swigCPtr, Layer.getCPtr(target));
 328             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 329         }
 330
 331         /// <summary>
 332         /// Raises the layer to the top.
 333         /// </summary>
 334         /// <since_tizen> 3 </since_tizen>
 335         public void RaiseToTop()
 336         {
 337             var parentChildren = Window.Instance.LayersChildren;
 338
 339             if (parentChildren != null)
 340             {
 341                 parentChildren.Remove(this);
 342                 parentChildren.Add(this);
 343             }
 344             NDalicPINVOKE.Layer_RaiseToTop(swigCPtr);
 345             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 346         }
 347
 348         /// <summary>
 349         /// Lowers the layer to the bottom.
 350         /// </summary>
 351         /// <since_tizen> 3 </since_tizen>
 352         public void LowerToBottom()
 353         {
 354             var parentChildren = Window.Instance.LayersChildren;
 355
 356             if (parentChildren != null)
 357             {
 358                 parentChildren.Remove(this);
 359                 parentChildren.Insert(0, this);
 360             }
 361
 362             NDalicPINVOKE.Layer_LowerToBottom(swigCPtr);
 363             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 364         }
 365
 366         /// <summary>
 367         /// Moves the layer directly above the given layer.<br />
 368         /// After the call, this layer's depth will be immediately above target.<br />
 369         /// </summary>
 370         /// <param name="target">The layer to get on top of.</param>
 371         /// <since_tizen> 3 </since_tizen>
 372         public void MoveAbove(Layer target)
 373         {
 374             NDalicPINVOKE.Layer_MoveAbove(swigCPtr, Layer.getCPtr(target));
 375             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376         }
 377
 378         /// <summary>
 379         /// Moves the layer directly below the given layer.<br />
 380         /// After the call, this layer's depth will be immediately below target.<br />
 381         /// </summary>
 382         /// <param name="target">The layer to get below of.</param>
 383         /// <since_tizen> 3 </since_tizen>
 384         public void MoveBelow(Layer target)
 385         {
 386             NDalicPINVOKE.Layer_MoveBelow(swigCPtr, Layer.getCPtr(target));
 387             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 388         }
 389
 390         private void SetBehavior(LayerBehavior behavior)
 391         {
 392             NDalicPINVOKE.Layer_SetBehavior(swigCPtr, (int)behavior);
 393             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 394         }
 395
 396         private LayerBehavior GetBehavior()
 397         {
 398             Layer.LayerBehavior ret = (Layer.LayerBehavior)NDalicPINVOKE.Layer_GetBehavior(swigCPtr);
 399             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 400             return ret;
 401         }
 402
 403         internal void SetSortFunction(SWIGTYPE_p_f_r_q_const__Dali__Vector3__float function)
 404         {
 405             NDalicPINVOKE.Layer_SetSortFunction(swigCPtr, SWIGTYPE_p_f_r_q_const__Dali__Vector3__float.getCPtr(function));
 406             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 407         }
 408
 409         internal void SetTouchConsumed(bool consume)
 410         {
 411             NDalicPINVOKE.Layer_SetTouchConsumed(swigCPtr, consume);
 412             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 413         }
 414
 415         internal bool IsTouchConsumed()
 416         {
 417             bool ret = NDalicPINVOKE.Layer_IsTouchConsumed(swigCPtr);
 418             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 419             return ret;
 420         }
 421
 422         internal void SetHoverConsumed(bool consume)
 423         {
 424             NDalicPINVOKE.Layer_SetHoverConsumed(swigCPtr, consume);
 425             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 426         }
 427
 428         internal bool IsHoverConsumed()
 429         {
 430             bool ret = NDalicPINVOKE.Layer_IsHoverConsumed(swigCPtr);
 431             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 432             return ret;
 433         }
 434
 435         /// <summary>
 436         /// Enumeration for the behavior of the layer.
 437         /// </summary>
 438         /// <since_tizen> 3 </since_tizen>
 439         public enum LayerBehavior
 440         {
 441             /// <summary>
 442             /// UI control rendering mode.
 443             /// </summary>
 444             /// <since_tizen> 3 </since_tizen>
 445             Layer2D,
 446             /// <summary>
 447             /// UI control rendering mode (default mode).
 448             /// This mode is designed for UI controls that can overlap. In this
 449             /// mode renderer order will be respective to the tree hierarchy of
 450             /// Actors.<br />
 451             /// The rendering order is depth first, so for the following actor tree,
 452             /// A will be drawn first, then B, D, E, then C, F.  This ensures that
 453             /// overlapping actors are drawn as expected (whereas, with breadth first
 454             /// traversal, the actors would interleave).<br />
 455             /// </summary>
 456             /// <since_tizen> 3 </since_tizen>
 457             LayerUI = Layer2D,
 458             /// <summary>
 459             /// Layer will use depth test.
 460             /// This mode is designed for a 3 dimensional scene where actors in front
 461             /// of other actors will obscure them, i.e. the actors are sorted by the
 462             /// distance from the camera.<br />
 463             /// When using this mode, a depth test will be used. A depth clear will
 464             /// happen for each layer, which means actors in a layer "above" other
 465             /// layers will be rendered in front of actors in those layers regardless
 466             /// of their Z positions (see Layer::Raise() and Layer::Lower()).<br />
 467             /// Opaque renderers are drawn first and write to the depth buffer.  Then
 468             /// transparent renderers are drawn with depth test enabled but depth
 469             /// write switched off.  Transparent renderers are drawn based on their
 470             /// distance from the camera.  A renderer's DEPTH_INDEX property is used to
 471             /// offset the distance to the camera when ordering transparent renderers.
 472             /// This is useful if you want to define the draw order of two or more
 473             /// transparent renderers that are equal distance from the camera.  Unlike
 474             /// LAYER_UI, parent-child relationship does not affect rendering order at
 475             /// all.
 476             /// </summary>
 477             /// <since_tizen> 3 </since_tizen>
 478             Layer3D
 479         }
 480
 481         internal enum TreeDepthMultiplier
 482         {
 483             TREE_DEPTH_MULTIPLIER = 10000
 484         }
 485
 486         /// <summary>
 487         /// Layer behavior, type String (Layer.LayerBehavior).
 488         /// </summary>
 489         /// <since_tizen> 3 </since_tizen>
 490         public Layer.LayerBehavior Behavior
 491         {
 492             get
 493             {
 494                 return GetBehavior();
 495             }
 496             set
 497             {
 498                 SetBehavior(value);
 499             }
 500         }
 501
 502         /// <summary>
 503         /// Internal only property to enable or disable clipping, type boolean.
 504         /// By default, this is false, i.e., the viewport of the layer is the entire window.
 505         /// </summary>
 506         internal bool ClippingEnabled
 507         {
 508             get
 509             {
 510                 bool ret = NDalicPINVOKE.Layer_IsClipping(swigCPtr);
 511                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 512                 return ret;
 513             }
 514             set
 515             {
 516                 NDalicPINVOKE.Layer_SetClipping(swigCPtr, value);
 517                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 518             }
 519         }
 520
 521         /// <summary>
 522         /// Sets the viewport (in window coordinates), type rectangle.
 523         /// The contents of the layer will not be visible outside this box, when ViewportEnabled is true.
 524         /// </summary>
 525         /// <since_tizen> 4 </since_tizen>
 526         public Rectangle Viewport
 527         {
 528             get
 529             {
 530                 if( ClippingEnabled )
 531                 {
 532                   Rectangle ret = new Rectangle(NDalicPINVOKE.Layer_GetClippingBox(swigCPtr), true);
 533                   if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 534                   return ret;
 535                 }
 536                 else
 537                 {
 538                   // Clipping not enabled so return the window size
 539                   Size2D windowSize = Window.Instance.Size;
 540                   Rectangle ret = new Rectangle(0, 0, windowSize.Width, windowSize.Height);
 541                   return ret;
 542                 }
 543             }
 544             set
 545             {
 546                 NDalicPINVOKE.Layer_SetClippingBox__SWIG_1(swigCPtr, Rectangle.getCPtr(value));
 547                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 548                 ClippingEnabled = true;
 549             }
 550         }
 551
 552         /// <summary>
 553         /// Retrieves and sets the layer's opacity.<br />
 554         /// </summary>
 555         /// <since_tizen> 3 </since_tizen>
 556         public float Opacity
 557         {
 558             get
 559             {
 560                 float temp = 0.0f;
 561                 GetProperty(View.Property.OPACITY).Get(out temp);
 562                 return temp;
 563             }
 564             set
 565             {
 566                 SetProperty(View.Property.OPACITY, new Tizen.NUI.PropertyValue(value));
 567             }
 568         }
 569
 570         /// <summary>
 571         /// Retrieves and sets the layer's visibility.
 572         /// </summary>
 573         /// <since_tizen> 3 </since_tizen>
 574         public bool Visibility
 575         {
 576             get
 577             {
 578                 bool temp = false;
 579                 GetProperty(View.Property.VISIBLE).Get(out temp);
 580                 return temp;
 581             }
 582             set
 583             {
 584                 SetProperty(View.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
 585             }
 586         }
 587
 588         /// <summary>
 589         /// Get the number of children held by the layer.
 590         /// </summary>
 591         /// <since_tizen> 3 </since_tizen>
 592         public new uint ChildCount
 593         {
 594             get
 595             {
 596                 return Convert.ToUInt32(Children.Count);
 597             }
 598         }
 599
 600         /// <summary>
 601         /// Gets or sets the layer's name.
 602         /// </summary>
 603         /// <since_tizen> 3 </since_tizen>
 604         public string Name
 605         {
 606             get
 607             {
 608                 return GetName();
 609             }
 610             set
 611             {
 612                 SetName(value);
 613             }
 614         }
 615
 616         internal string GetName()
 617         {
 618             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
 619             if (NDalicPINVOKE.SWIGPendingException.Pending)
 620                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 621             return ret;
 622         }
 623
 624         internal void SetName(string name)
 625         {
 626             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
 627             if (NDalicPINVOKE.SWIGPendingException.Pending)
 628                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 629         }
 630
 631     }
 632 }