internals/src/EflSharp/EflSharp/efl/efl_ui_pan.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Elementary pan class</summary>
  13 [Efl.Ui.Pan.NativeMethods]
  14 public class Pan : Efl.Canvas.Group, Efl.Eo.IWrapper,Efl.IContent
  15 {
  16     ///<summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(Pan))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  33         efl_ui_pan_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Pan"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     public Pan(Efl.Object parent= null
  37             ) : base(efl_ui_pan_class_get(), typeof(Pan), parent)
  38     {
  39         FinishInstantiation();
  40     }
  41
  42     /// <summary>Initializes a new instance of the <see cref="Pan"/> class.
  43     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  44     /// <param name="raw">The native pointer to be wrapped.</param>
  45     protected Pan(System.IntPtr raw) : base(raw)
  46     {
  47             }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Pan"/> class.
  50     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  51     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  52     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  53     /// <param name="parent">The Efl.Object parent of this instance.</param>
  54     protected Pan(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  55     {
  56     }
  57
  58     /// <summary>Verifies if the given object is equal to this one.</summary>
  59     /// <param name="instance">The object to compare to.</param>
  60     /// <returns>True if both objects point to the same native object.</returns>
  61     public override bool Equals(object instance)
  62     {
  63         var other = instance as Efl.Object;
  64         if (other == null)
  65         {
  66             return false;
  67         }
  68         return this.NativeHandle == other.NativeHandle;
  69     }
  70
  71     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  72     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  73     public override int GetHashCode()
  74     {
  75         return this.NativeHandle.ToInt32();
  76     }
  77
  78     /// <summary>Turns the native pointer into a string representation.</summary>
  79     /// <returns>A string with the type and the native pointer for this object.</returns>
  80     public override String ToString()
  81     {
  82         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  83     }
  84
  85     /// <summary>Called when pan content changed</summary>
  86     public event EventHandler PanContentChangedEvt
  87     {
  88         add
  89         {
  90             lock (eventLock)
  91             {
  92                 var wRef = new WeakReference(this);
  93                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  94                 {
  95                     var obj = wRef.Target as Efl.Eo.IWrapper;
  96                     if (obj != null)
  97                     {
  98                         EventArgs args = EventArgs.Empty;
  99                         try
 100                         {
 101                             value?.Invoke(obj, args);
 102                         }
 103                         catch (Exception e)
 104                         {
 105                             Eina.Log.Error(e.ToString());
 106                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 107                         }
 108                     }
 109                 };
 110
 111                 string key = "_EFL_UI_PAN_EVENT_PAN_CONTENT_CHANGED";
 112                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 113             }
 114         }
 115
 116         remove
 117         {
 118             lock (eventLock)
 119             {
 120                 string key = "_EFL_UI_PAN_EVENT_PAN_CONTENT_CHANGED";
 121                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 122             }
 123         }
 124     }
 125     ///<summary>Method to raise event PanContentChangedEvt.</summary>
 126     public void OnPanContentChangedEvt(EventArgs e)
 127     {
 128         var key = "_EFL_UI_PAN_EVENT_PAN_CONTENT_CHANGED";
 129         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 130         if (desc == IntPtr.Zero)
 131         {
 132             Eina.Log.Error($"Failed to get native event {key}");
 133             return;
 134         }
 135
 136         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 137     }
 138     /// <summary>Called when pan viewport changed</summary>
 139     public event EventHandler PanViewportChangedEvt
 140     {
 141         add
 142         {
 143             lock (eventLock)
 144             {
 145                 var wRef = new WeakReference(this);
 146                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 147                 {
 148                     var obj = wRef.Target as Efl.Eo.IWrapper;
 149                     if (obj != null)
 150                     {
 151                         EventArgs args = EventArgs.Empty;
 152                         try
 153                         {
 154                             value?.Invoke(obj, args);
 155                         }
 156                         catch (Exception e)
 157                         {
 158                             Eina.Log.Error(e.ToString());
 159                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 160                         }
 161                     }
 162                 };
 163
 164                 string key = "_EFL_UI_PAN_EVENT_PAN_VIEWPORT_CHANGED";
 165                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 166             }
 167         }
 168
 169         remove
 170         {
 171             lock (eventLock)
 172             {
 173                 string key = "_EFL_UI_PAN_EVENT_PAN_VIEWPORT_CHANGED";
 174                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 175             }
 176         }
 177     }
 178     ///<summary>Method to raise event PanViewportChangedEvt.</summary>
 179     public void OnPanViewportChangedEvt(EventArgs e)
 180     {
 181         var key = "_EFL_UI_PAN_EVENT_PAN_VIEWPORT_CHANGED";
 182         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 183         if (desc == IntPtr.Zero)
 184         {
 185             Eina.Log.Error($"Failed to get native event {key}");
 186             return;
 187         }
 188
 189         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 190     }
 191     /// <summary>Called when pan position changed</summary>
 192     public event EventHandler PanPositionChangedEvt
 193     {
 194         add
 195         {
 196             lock (eventLock)
 197             {
 198                 var wRef = new WeakReference(this);
 199                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 200                 {
 201                     var obj = wRef.Target as Efl.Eo.IWrapper;
 202                     if (obj != null)
 203                     {
 204                         EventArgs args = EventArgs.Empty;
 205                         try
 206                         {
 207                             value?.Invoke(obj, args);
 208                         }
 209                         catch (Exception e)
 210                         {
 211                             Eina.Log.Error(e.ToString());
 212                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 213                         }
 214                     }
 215                 };
 216
 217                 string key = "_EFL_UI_PAN_EVENT_PAN_POSITION_CHANGED";
 218                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 219             }
 220         }
 221
 222         remove
 223         {
 224             lock (eventLock)
 225             {
 226                 string key = "_EFL_UI_PAN_EVENT_PAN_POSITION_CHANGED";
 227                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 228             }
 229         }
 230     }
 231     ///<summary>Method to raise event PanPositionChangedEvt.</summary>
 232     public void OnPanPositionChangedEvt(EventArgs e)
 233     {
 234         var key = "_EFL_UI_PAN_EVENT_PAN_POSITION_CHANGED";
 235         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 236         if (desc == IntPtr.Zero)
 237         {
 238             Eina.Log.Error($"Failed to get native event {key}");
 239             return;
 240         }
 241
 242         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 243     }
 244     /// <summary>Sent after the content is set or unset using the current content object.
 245     /// (Since EFL 1.22)</summary>
 246     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
 247     {
 248         add
 249         {
 250             lock (eventLock)
 251             {
 252                 var wRef = new WeakReference(this);
 253                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 254                 {
 255                     var obj = wRef.Target as Efl.Eo.IWrapper;
 256                     if (obj != null)
 257                     {
 258                                                 Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
 259                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 260                         try
 261                         {
 262                             value?.Invoke(obj, args);
 263                         }
 264                         catch (Exception e)
 265                         {
 266                             Eina.Log.Error(e.ToString());
 267                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 268                         }
 269                     }
 270                 };
 271
 272                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 273                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 274             }
 275         }
 276
 277         remove
 278         {
 279             lock (eventLock)
 280             {
 281                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 282                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 283             }
 284         }
 285     }
 286     ///<summary>Method to raise event ContentChangedEvt.</summary>
 287     public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 288     {
 289         var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 290         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 291         if (desc == IntPtr.Zero)
 292         {
 293             Eina.Log.Error($"Failed to get native event {key}");
 294             return;
 295         }
 296
 297         IntPtr info = e.arg.NativeHandle;
 298         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 299     }
 300     /// <summary>Position</summary>
 301     virtual public Eina.Position2D GetPanPosition() {
 302          var _ret_var = Efl.Ui.Pan.NativeMethods.efl_ui_pan_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 303         Eina.Error.RaiseIfUnhandledException();
 304         return _ret_var;
 305  }
 306     /// <summary>Position</summary>
 307     virtual public void SetPanPosition(Eina.Position2D position) {
 308          Eina.Position2D.NativeStruct _in_position = position;
 309                         Efl.Ui.Pan.NativeMethods.efl_ui_pan_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_position);
 310         Eina.Error.RaiseIfUnhandledException();
 311                          }
 312     /// <summary>Content size</summary>
 313     virtual public Eina.Size2D GetContentSize() {
 314          var _ret_var = Efl.Ui.Pan.NativeMethods.efl_ui_pan_content_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 315         Eina.Error.RaiseIfUnhandledException();
 316         return _ret_var;
 317  }
 318     /// <summary>The minimal position to scroll</summary>
 319     virtual public Eina.Position2D GetPanPositionMin() {
 320          var _ret_var = Efl.Ui.Pan.NativeMethods.efl_ui_pan_position_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 321         Eina.Error.RaiseIfUnhandledException();
 322         return _ret_var;
 323  }
 324     /// <summary>The maximal position to scroll</summary>
 325     virtual public Eina.Position2D GetPanPositionMax() {
 326          var _ret_var = Efl.Ui.Pan.NativeMethods.efl_ui_pan_position_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 327         Eina.Error.RaiseIfUnhandledException();
 328         return _ret_var;
 329  }
 330     /// <summary>Sub-object currently set as this object&apos;s single content.
 331     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 332     /// (Since EFL 1.22)</summary>
 333     /// <returns>The sub-object.</returns>
 334     virtual public Efl.Gfx.IEntity GetContent() {
 335          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 336         Eina.Error.RaiseIfUnhandledException();
 337         return _ret_var;
 338  }
 339     /// <summary>Sub-object currently set as this object&apos;s single content.
 340     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 341     /// (Since EFL 1.22)</summary>
 342     /// <param name="content">The sub-object.</param>
 343     /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
 344     virtual public bool SetContent(Efl.Gfx.IEntity content) {
 345                                  var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
 346         Eina.Error.RaiseIfUnhandledException();
 347                         return _ret_var;
 348  }
 349     /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
 350     /// (Since EFL 1.22)</summary>
 351     /// <returns>Unswallowed object</returns>
 352     virtual public Efl.Gfx.IEntity UnsetContent() {
 353          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 354         Eina.Error.RaiseIfUnhandledException();
 355         return _ret_var;
 356  }
 357     /// <summary>Position</summary>
 358     public Eina.Position2D PanPosition {
 359         get { return GetPanPosition(); }
 360         set { SetPanPosition(value); }
 361     }
 362     /// <summary>Content size</summary>
 363     public Eina.Size2D ContentSize {
 364         get { return GetContentSize(); }
 365     }
 366     /// <summary>The minimal position to scroll</summary>
 367     public Eina.Position2D PanPositionMin {
 368         get { return GetPanPositionMin(); }
 369     }
 370     /// <summary>The maximal position to scroll</summary>
 371     public Eina.Position2D PanPositionMax {
 372         get { return GetPanPositionMax(); }
 373     }
 374     /// <summary>Sub-object currently set as this object&apos;s single content.
 375 /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 376 /// (Since EFL 1.22)</summary>
 377 /// <value>The sub-object.</value>
 378     public Efl.Gfx.IEntity Content {
 379         get { return GetContent(); }
 380         set { SetContent(value); }
 381     }
 382     private static IntPtr GetEflClassStatic()
 383     {
 384         return Efl.Ui.Pan.efl_ui_pan_class_get();
 385     }
 386     /// <summary>Wrapper for native methods and virtual method delegates.
 387     /// For internal use by generated code only.</summary>
 388     public new class NativeMethods : Efl.Canvas.Group.NativeMethods
 389     {
 390         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 391         /// <summary>Gets the list of Eo operations to override.</summary>
 392         /// <returns>The list of Eo operations to be overload.</returns>
 393         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 394         {
 395             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 396             var methods = Efl.Eo.Globals.GetUserMethods(type);
 397
 398             if (efl_ui_pan_position_get_static_delegate == null)
 399             {
 400                 efl_ui_pan_position_get_static_delegate = new efl_ui_pan_position_get_delegate(pan_position_get);
 401             }
 402
 403             if (methods.FirstOrDefault(m => m.Name == "GetPanPosition") != null)
 404             {
 405                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_pan_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pan_position_get_static_delegate) });
 406             }
 407
 408             if (efl_ui_pan_position_set_static_delegate == null)
 409             {
 410                 efl_ui_pan_position_set_static_delegate = new efl_ui_pan_position_set_delegate(pan_position_set);
 411             }
 412
 413             if (methods.FirstOrDefault(m => m.Name == "SetPanPosition") != null)
 414             {
 415                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_pan_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pan_position_set_static_delegate) });
 416             }
 417
 418             if (efl_ui_pan_content_size_get_static_delegate == null)
 419             {
 420                 efl_ui_pan_content_size_get_static_delegate = new efl_ui_pan_content_size_get_delegate(content_size_get);
 421             }
 422
 423             if (methods.FirstOrDefault(m => m.Name == "GetContentSize") != null)
 424             {
 425                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_pan_content_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pan_content_size_get_static_delegate) });
 426             }
 427
 428             if (efl_ui_pan_position_min_get_static_delegate == null)
 429             {
 430                 efl_ui_pan_position_min_get_static_delegate = new efl_ui_pan_position_min_get_delegate(pan_position_min_get);
 431             }
 432
 433             if (methods.FirstOrDefault(m => m.Name == "GetPanPositionMin") != null)
 434             {
 435                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_pan_position_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pan_position_min_get_static_delegate) });
 436             }
 437
 438             if (efl_ui_pan_position_max_get_static_delegate == null)
 439             {
 440                 efl_ui_pan_position_max_get_static_delegate = new efl_ui_pan_position_max_get_delegate(pan_position_max_get);
 441             }
 442
 443             if (methods.FirstOrDefault(m => m.Name == "GetPanPositionMax") != null)
 444             {
 445                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_pan_position_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pan_position_max_get_static_delegate) });
 446             }
 447
 448             if (efl_content_get_static_delegate == null)
 449             {
 450                 efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 451             }
 452
 453             if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
 454             {
 455                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
 456             }
 457
 458             if (efl_content_set_static_delegate == null)
 459             {
 460                 efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 461             }
 462
 463             if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
 464             {
 465                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
 466             }
 467
 468             if (efl_content_unset_static_delegate == null)
 469             {
 470                 efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 471             }
 472
 473             if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
 474             {
 475                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
 476             }
 477
 478             descs.AddRange(base.GetEoOps(type));
 479             return descs;
 480         }
 481         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 482         /// <returns>The native class pointer.</returns>
 483         public override IntPtr GetEflClass()
 484         {
 485             return Efl.Ui.Pan.efl_ui_pan_class_get();
 486         }
 487
 488         #pragma warning disable CA1707, SA1300, SA1600
 489
 490
 491         private delegate Eina.Position2D.NativeStruct efl_ui_pan_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
 492
 493
 494         public delegate Eina.Position2D.NativeStruct efl_ui_pan_position_get_api_delegate(System.IntPtr obj);
 495
 496         public static Efl.Eo.FunctionWrapper<efl_ui_pan_position_get_api_delegate> efl_ui_pan_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pan_position_get_api_delegate>(Module, "efl_ui_pan_position_get");
 497
 498         private static Eina.Position2D.NativeStruct pan_position_get(System.IntPtr obj, System.IntPtr pd)
 499         {
 500             Eina.Log.Debug("function efl_ui_pan_position_get was called");
 501             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 502             if (wrapper != null)
 503             {
 504             Eina.Position2D _ret_var = default(Eina.Position2D);
 505                 try
 506                 {
 507                     _ret_var = ((Pan)wrapper).GetPanPosition();
 508                 }
 509                 catch (Exception e)
 510                 {
 511                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 512                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 513                 }
 514
 515         return _ret_var;
 516
 517             }
 518             else
 519             {
 520                 return efl_ui_pan_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 521             }
 522         }
 523
 524         private static efl_ui_pan_position_get_delegate efl_ui_pan_position_get_static_delegate;
 525
 526
 527         private delegate void efl_ui_pan_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct position);
 528
 529
 530         public delegate void efl_ui_pan_position_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct position);
 531
 532         public static Efl.Eo.FunctionWrapper<efl_ui_pan_position_set_api_delegate> efl_ui_pan_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pan_position_set_api_delegate>(Module, "efl_ui_pan_position_set");
 533
 534         private static void pan_position_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct position)
 535         {
 536             Eina.Log.Debug("function efl_ui_pan_position_set was called");
 537             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 538             if (wrapper != null)
 539             {
 540         Eina.Position2D _in_position = position;
 541
 542                 try
 543                 {
 544                     ((Pan)wrapper).SetPanPosition(_in_position);
 545                 }
 546                 catch (Exception e)
 547                 {
 548                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 549                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 550                 }
 551
 552
 553             }
 554             else
 555             {
 556                 efl_ui_pan_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
 557             }
 558         }
 559
 560         private static efl_ui_pan_position_set_delegate efl_ui_pan_position_set_static_delegate;
 561
 562
 563         private delegate Eina.Size2D.NativeStruct efl_ui_pan_content_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 564
 565
 566         public delegate Eina.Size2D.NativeStruct efl_ui_pan_content_size_get_api_delegate(System.IntPtr obj);
 567
 568         public static Efl.Eo.FunctionWrapper<efl_ui_pan_content_size_get_api_delegate> efl_ui_pan_content_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pan_content_size_get_api_delegate>(Module, "efl_ui_pan_content_size_get");
 569
 570         private static Eina.Size2D.NativeStruct content_size_get(System.IntPtr obj, System.IntPtr pd)
 571         {
 572             Eina.Log.Debug("function efl_ui_pan_content_size_get was called");
 573             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 574             if (wrapper != null)
 575             {
 576             Eina.Size2D _ret_var = default(Eina.Size2D);
 577                 try
 578                 {
 579                     _ret_var = ((Pan)wrapper).GetContentSize();
 580                 }
 581                 catch (Exception e)
 582                 {
 583                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 584                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 585                 }
 586
 587         return _ret_var;
 588
 589             }
 590             else
 591             {
 592                 return efl_ui_pan_content_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 593             }
 594         }
 595
 596         private static efl_ui_pan_content_size_get_delegate efl_ui_pan_content_size_get_static_delegate;
 597
 598
 599         private delegate Eina.Position2D.NativeStruct efl_ui_pan_position_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 600
 601
 602         public delegate Eina.Position2D.NativeStruct efl_ui_pan_position_min_get_api_delegate(System.IntPtr obj);
 603
 604         public static Efl.Eo.FunctionWrapper<efl_ui_pan_position_min_get_api_delegate> efl_ui_pan_position_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pan_position_min_get_api_delegate>(Module, "efl_ui_pan_position_min_get");
 605
 606         private static Eina.Position2D.NativeStruct pan_position_min_get(System.IntPtr obj, System.IntPtr pd)
 607         {
 608             Eina.Log.Debug("function efl_ui_pan_position_min_get was called");
 609             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 610             if (wrapper != null)
 611             {
 612             Eina.Position2D _ret_var = default(Eina.Position2D);
 613                 try
 614                 {
 615                     _ret_var = ((Pan)wrapper).GetPanPositionMin();
 616                 }
 617                 catch (Exception e)
 618                 {
 619                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 620                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 621                 }
 622
 623         return _ret_var;
 624
 625             }
 626             else
 627             {
 628                 return efl_ui_pan_position_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 629             }
 630         }
 631
 632         private static efl_ui_pan_position_min_get_delegate efl_ui_pan_position_min_get_static_delegate;
 633
 634
 635         private delegate Eina.Position2D.NativeStruct efl_ui_pan_position_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 636
 637
 638         public delegate Eina.Position2D.NativeStruct efl_ui_pan_position_max_get_api_delegate(System.IntPtr obj);
 639
 640         public static Efl.Eo.FunctionWrapper<efl_ui_pan_position_max_get_api_delegate> efl_ui_pan_position_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pan_position_max_get_api_delegate>(Module, "efl_ui_pan_position_max_get");
 641
 642         private static Eina.Position2D.NativeStruct pan_position_max_get(System.IntPtr obj, System.IntPtr pd)
 643         {
 644             Eina.Log.Debug("function efl_ui_pan_position_max_get was called");
 645             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 646             if (wrapper != null)
 647             {
 648             Eina.Position2D _ret_var = default(Eina.Position2D);
 649                 try
 650                 {
 651                     _ret_var = ((Pan)wrapper).GetPanPositionMax();
 652                 }
 653                 catch (Exception e)
 654                 {
 655                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 656                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 657                 }
 658
 659         return _ret_var;
 660
 661             }
 662             else
 663             {
 664                 return efl_ui_pan_position_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 665             }
 666         }
 667
 668         private static efl_ui_pan_position_max_get_delegate efl_ui_pan_position_max_get_static_delegate;
 669
 670         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 671         private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
 672
 673         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 674         public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
 675
 676         public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
 677
 678         private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
 679         {
 680             Eina.Log.Debug("function efl_content_get was called");
 681             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 682             if (wrapper != null)
 683             {
 684             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 685                 try
 686                 {
 687                     _ret_var = ((Pan)wrapper).GetContent();
 688                 }
 689                 catch (Exception e)
 690                 {
 691                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 692                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 693                 }
 694
 695         return _ret_var;
 696
 697             }
 698             else
 699             {
 700                 return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 701             }
 702         }
 703
 704         private static efl_content_get_delegate efl_content_get_static_delegate;
 705
 706         [return: MarshalAs(UnmanagedType.U1)]
 707         private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
 708
 709         [return: MarshalAs(UnmanagedType.U1)]
 710         public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
 711
 712         public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
 713
 714         private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
 715         {
 716             Eina.Log.Debug("function efl_content_set was called");
 717             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 718             if (wrapper != null)
 719             {
 720                                     bool _ret_var = default(bool);
 721                 try
 722                 {
 723                     _ret_var = ((Pan)wrapper).SetContent(content);
 724                 }
 725                 catch (Exception e)
 726                 {
 727                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 728                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 729                 }
 730
 731                         return _ret_var;
 732
 733             }
 734             else
 735             {
 736                 return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
 737             }
 738         }
 739
 740         private static efl_content_set_delegate efl_content_set_static_delegate;
 741
 742         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 743         private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
 744
 745         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 746         public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
 747
 748         public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
 749
 750         private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
 751         {
 752             Eina.Log.Debug("function efl_content_unset was called");
 753             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 754             if (wrapper != null)
 755             {
 756             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 757                 try
 758                 {
 759                     _ret_var = ((Pan)wrapper).UnsetContent();
 760                 }
 761                 catch (Exception e)
 762                 {
 763                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 764                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 765                 }
 766
 767         return _ret_var;
 768
 769             }
 770             else
 771             {
 772                 return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 773             }
 774         }
 775
 776         private static efl_content_unset_delegate efl_content_unset_static_delegate;
 777
 778         #pragma warning restore CA1707, SA1300, SA1600
 779
 780 }
 781 }
 782 }
 783
 784 }
 785