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.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Elementary pan class</summary>
   9 [PanNativeInherit]
  10 public class Pan : Efl.Canvas.Group, Efl.Eo.IWrapper,Efl.IContent
  11 {
  12     ///<summary>Pointer to the native class description.</summary>
  13     public override System.IntPtr NativeClass {
  14         get {
  15             if (((object)this).GetType() == typeof (Pan))
  16                 return Efl.Ui.PanNativeInherit.GetEflClassStatic();
  17             else
  18                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  19         }
  20     }
  21     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  22         efl_ui_pan_class_get();
  23     ///<summary>Creates a new instance.</summary>
  24     ///<param name="parent">Parent instance.</param>
  25     public Pan(Efl.Object parent= null
  26             ) :
  27         base(efl_ui_pan_class_get(), typeof(Pan), parent)
  28     {
  29         FinishInstantiation();
  30     }
  31     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  32     protected Pan(System.IntPtr raw) : base(raw)
  33     {
  34                 RegisterEventProxies();
  35     }
  36     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  37     protected Pan(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  38     ///<summary>Verifies if the given object is equal to this one.</summary>
  39     public override bool Equals(object obj)
  40     {
  41         var other = obj as Efl.Object;
  42         if (other == null)
  43             return false;
  44         return this.NativeHandle == other.NativeHandle;
  45     }
  46     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  47     public override int GetHashCode()
  48     {
  49         return this.NativeHandle.ToInt32();
  50     }
  51     ///<summary>Turns the native pointer into a string representation.</summary>
  52     public override String ToString()
  53     {
  54         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  55     }
  56 private static object PanContentChangedEvtKey = new object();
  57     /// <summary>Called when pan content changed</summary>
  58     public event EventHandler PanContentChangedEvt
  59     {
  60         add {
  61             lock (eventLock) {
  62                 string key = "_EFL_UI_PAN_EVENT_PAN_CONTENT_CHANGED";
  63                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_PanContentChangedEvt_delegate)) {
  64                     eventHandlers.AddHandler(PanContentChangedEvtKey , value);
  65                 } else
  66                     Eina.Log.Error($"Error adding proxy for event {key}");
  67             }
  68         }
  69         remove {
  70             lock (eventLock) {
  71                 string key = "_EFL_UI_PAN_EVENT_PAN_CONTENT_CHANGED";
  72                 if (RemoveNativeEventHandler(key, this.evt_PanContentChangedEvt_delegate)) {
  73                     eventHandlers.RemoveHandler(PanContentChangedEvtKey , value);
  74                 } else
  75                     Eina.Log.Error($"Error removing proxy for event {key}");
  76             }
  77         }
  78     }
  79     ///<summary>Method to raise event PanContentChangedEvt.</summary>
  80     public void On_PanContentChangedEvt(EventArgs e)
  81     {
  82         EventHandler evt;
  83         lock (eventLock) {
  84         evt = (EventHandler)eventHandlers[PanContentChangedEvtKey];
  85         }
  86         evt?.Invoke(this, e);
  87     }
  88     Efl.EventCb evt_PanContentChangedEvt_delegate;
  89     private void on_PanContentChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  90     {
  91         EventArgs args = EventArgs.Empty;
  92         try {
  93             On_PanContentChangedEvt(args);
  94         } catch (Exception e) {
  95             Eina.Log.Error(e.ToString());
  96             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  97         }
  98     }
  99
 100 private static object PanViewportChangedEvtKey = new object();
 101     /// <summary>Called when pan viewport changed</summary>
 102     public event EventHandler PanViewportChangedEvt
 103     {
 104         add {
 105             lock (eventLock) {
 106                 string key = "_EFL_UI_PAN_EVENT_PAN_VIEWPORT_CHANGED";
 107                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_PanViewportChangedEvt_delegate)) {
 108                     eventHandlers.AddHandler(PanViewportChangedEvtKey , value);
 109                 } else
 110                     Eina.Log.Error($"Error adding proxy for event {key}");
 111             }
 112         }
 113         remove {
 114             lock (eventLock) {
 115                 string key = "_EFL_UI_PAN_EVENT_PAN_VIEWPORT_CHANGED";
 116                 if (RemoveNativeEventHandler(key, this.evt_PanViewportChangedEvt_delegate)) {
 117                     eventHandlers.RemoveHandler(PanViewportChangedEvtKey , value);
 118                 } else
 119                     Eina.Log.Error($"Error removing proxy for event {key}");
 120             }
 121         }
 122     }
 123     ///<summary>Method to raise event PanViewportChangedEvt.</summary>
 124     public void On_PanViewportChangedEvt(EventArgs e)
 125     {
 126         EventHandler evt;
 127         lock (eventLock) {
 128         evt = (EventHandler)eventHandlers[PanViewportChangedEvtKey];
 129         }
 130         evt?.Invoke(this, e);
 131     }
 132     Efl.EventCb evt_PanViewportChangedEvt_delegate;
 133     private void on_PanViewportChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 134     {
 135         EventArgs args = EventArgs.Empty;
 136         try {
 137             On_PanViewportChangedEvt(args);
 138         } catch (Exception e) {
 139             Eina.Log.Error(e.ToString());
 140             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 141         }
 142     }
 143
 144 private static object PanPositionChangedEvtKey = new object();
 145     /// <summary>Called when pan position changed</summary>
 146     public event EventHandler PanPositionChangedEvt
 147     {
 148         add {
 149             lock (eventLock) {
 150                 string key = "_EFL_UI_PAN_EVENT_PAN_POSITION_CHANGED";
 151                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_PanPositionChangedEvt_delegate)) {
 152                     eventHandlers.AddHandler(PanPositionChangedEvtKey , value);
 153                 } else
 154                     Eina.Log.Error($"Error adding proxy for event {key}");
 155             }
 156         }
 157         remove {
 158             lock (eventLock) {
 159                 string key = "_EFL_UI_PAN_EVENT_PAN_POSITION_CHANGED";
 160                 if (RemoveNativeEventHandler(key, this.evt_PanPositionChangedEvt_delegate)) {
 161                     eventHandlers.RemoveHandler(PanPositionChangedEvtKey , value);
 162                 } else
 163                     Eina.Log.Error($"Error removing proxy for event {key}");
 164             }
 165         }
 166     }
 167     ///<summary>Method to raise event PanPositionChangedEvt.</summary>
 168     public void On_PanPositionChangedEvt(EventArgs e)
 169     {
 170         EventHandler evt;
 171         lock (eventLock) {
 172         evt = (EventHandler)eventHandlers[PanPositionChangedEvtKey];
 173         }
 174         evt?.Invoke(this, e);
 175     }
 176     Efl.EventCb evt_PanPositionChangedEvt_delegate;
 177     private void on_PanPositionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 178     {
 179         EventArgs args = EventArgs.Empty;
 180         try {
 181             On_PanPositionChangedEvt(args);
 182         } catch (Exception e) {
 183             Eina.Log.Error(e.ToString());
 184             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 185         }
 186     }
 187
 188 private static object ContentChangedEvtKey = new object();
 189     /// <summary>Sent after the content is set or unset using the current content object.
 190     /// (Since EFL 1.22)</summary>
 191     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
 192     {
 193         add {
 194             lock (eventLock) {
 195                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 196                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_ContentChangedEvt_delegate)) {
 197                     eventHandlers.AddHandler(ContentChangedEvtKey , value);
 198                 } else
 199                     Eina.Log.Error($"Error adding proxy for event {key}");
 200             }
 201         }
 202         remove {
 203             lock (eventLock) {
 204                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 205                 if (RemoveNativeEventHandler(key, this.evt_ContentChangedEvt_delegate)) {
 206                     eventHandlers.RemoveHandler(ContentChangedEvtKey , value);
 207                 } else
 208                     Eina.Log.Error($"Error removing proxy for event {key}");
 209             }
 210         }
 211     }
 212     ///<summary>Method to raise event ContentChangedEvt.</summary>
 213     public void On_ContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 214     {
 215         EventHandler<Efl.IContentContentChangedEvt_Args> evt;
 216         lock (eventLock) {
 217         evt = (EventHandler<Efl.IContentContentChangedEvt_Args>)eventHandlers[ContentChangedEvtKey];
 218         }
 219         evt?.Invoke(this, e);
 220     }
 221     Efl.EventCb evt_ContentChangedEvt_delegate;
 222     private void on_ContentChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 223     {
 224         Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
 225       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 226         try {
 227             On_ContentChangedEvt(args);
 228         } catch (Exception e) {
 229             Eina.Log.Error(e.ToString());
 230             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 231         }
 232     }
 233
 234     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 235     protected override void RegisterEventProxies()
 236     {
 237         base.RegisterEventProxies();
 238         evt_PanContentChangedEvt_delegate = new Efl.EventCb(on_PanContentChangedEvt_NativeCallback);
 239         evt_PanViewportChangedEvt_delegate = new Efl.EventCb(on_PanViewportChangedEvt_NativeCallback);
 240         evt_PanPositionChangedEvt_delegate = new Efl.EventCb(on_PanPositionChangedEvt_NativeCallback);
 241         evt_ContentChangedEvt_delegate = new Efl.EventCb(on_ContentChangedEvt_NativeCallback);
 242     }
 243     /// <summary>Position</summary>
 244     /// <returns></returns>
 245     virtual public Eina.Position2D GetPanPosition() {
 246          var _ret_var = Efl.Ui.PanNativeInherit.efl_ui_pan_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 247         Eina.Error.RaiseIfUnhandledException();
 248         return _ret_var;
 249  }
 250     /// <summary>Position</summary>
 251     /// <param name="position"></param>
 252     /// <returns></returns>
 253     virtual public void SetPanPosition( Eina.Position2D position) {
 254          Eina.Position2D.NativeStruct _in_position = position;
 255                         Efl.Ui.PanNativeInherit.efl_ui_pan_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_position);
 256         Eina.Error.RaiseIfUnhandledException();
 257                          }
 258     /// <summary>Content size</summary>
 259     /// <returns></returns>
 260     virtual public Eina.Size2D GetContentSize() {
 261          var _ret_var = Efl.Ui.PanNativeInherit.efl_ui_pan_content_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 262         Eina.Error.RaiseIfUnhandledException();
 263         return _ret_var;
 264  }
 265     /// <summary>The minimal position to scroll</summary>
 266     /// <returns></returns>
 267     virtual public Eina.Position2D GetPanPositionMin() {
 268          var _ret_var = Efl.Ui.PanNativeInherit.efl_ui_pan_position_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 269         Eina.Error.RaiseIfUnhandledException();
 270         return _ret_var;
 271  }
 272     /// <summary>The maximal position to scroll</summary>
 273     /// <returns></returns>
 274     virtual public Eina.Position2D GetPanPositionMax() {
 275          var _ret_var = Efl.Ui.PanNativeInherit.efl_ui_pan_position_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 276         Eina.Error.RaiseIfUnhandledException();
 277         return _ret_var;
 278  }
 279     /// <summary>Swallowed sub-object contained in this object.
 280     /// (Since EFL 1.22)</summary>
 281     /// <returns>The object to swallow.</returns>
 282     virtual public Efl.Gfx.IEntity GetContent() {
 283          var _ret_var = Efl.IContentNativeInherit.efl_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 284         Eina.Error.RaiseIfUnhandledException();
 285         return _ret_var;
 286  }
 287     /// <summary>Swallowed sub-object contained in this object.
 288     /// (Since EFL 1.22)</summary>
 289     /// <param name="content">The object to swallow.</param>
 290     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 291     virtual public bool SetContent( Efl.Gfx.IEntity content) {
 292                                  var _ret_var = Efl.IContentNativeInherit.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), content);
 293         Eina.Error.RaiseIfUnhandledException();
 294                         return _ret_var;
 295  }
 296     /// <summary>Unswallow the object in the current container and return it.
 297     /// (Since EFL 1.22)</summary>
 298     /// <returns>Unswallowed object</returns>
 299     virtual public Efl.Gfx.IEntity UnsetContent() {
 300          var _ret_var = Efl.IContentNativeInherit.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 301         Eina.Error.RaiseIfUnhandledException();
 302         return _ret_var;
 303  }
 304     /// <summary>Position</summary>
 305 /// <value></value>
 306     public Eina.Position2D PanPosition {
 307         get { return GetPanPosition(); }
 308         set { SetPanPosition( value); }
 309     }
 310     /// <summary>Content size</summary>
 311 /// <value></value>
 312     public Eina.Size2D ContentSize {
 313         get { return GetContentSize(); }
 314     }
 315     /// <summary>The minimal position to scroll</summary>
 316 /// <value></value>
 317     public Eina.Position2D PanPositionMin {
 318         get { return GetPanPositionMin(); }
 319     }
 320     /// <summary>The maximal position to scroll</summary>
 321 /// <value></value>
 322     public Eina.Position2D PanPositionMax {
 323         get { return GetPanPositionMax(); }
 324     }
 325     /// <summary>Swallowed sub-object contained in this object.
 326 /// (Since EFL 1.22)</summary>
 327 /// <value>The object to swallow.</value>
 328     public Efl.Gfx.IEntity Content {
 329         get { return GetContent(); }
 330         set { SetContent( value); }
 331     }
 332     private static IntPtr GetEflClassStatic()
 333     {
 334         return Efl.Ui.Pan.efl_ui_pan_class_get();
 335     }
 336 }
 337 public class PanNativeInherit : Efl.Canvas.GroupNativeInherit{
 338     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 339     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 340     {
 341         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 342         var methods = Efl.Eo.Globals.GetUserMethods(type);
 343         if (efl_ui_pan_position_get_static_delegate == null)
 344             efl_ui_pan_position_get_static_delegate = new efl_ui_pan_position_get_delegate(pan_position_get);
 345         if (methods.FirstOrDefault(m => m.Name == "GetPanPosition") != null)
 346             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)});
 347         if (efl_ui_pan_position_set_static_delegate == null)
 348             efl_ui_pan_position_set_static_delegate = new efl_ui_pan_position_set_delegate(pan_position_set);
 349         if (methods.FirstOrDefault(m => m.Name == "SetPanPosition") != null)
 350             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)});
 351         if (efl_ui_pan_content_size_get_static_delegate == null)
 352             efl_ui_pan_content_size_get_static_delegate = new efl_ui_pan_content_size_get_delegate(content_size_get);
 353         if (methods.FirstOrDefault(m => m.Name == "GetContentSize") != null)
 354             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)});
 355         if (efl_ui_pan_position_min_get_static_delegate == null)
 356             efl_ui_pan_position_min_get_static_delegate = new efl_ui_pan_position_min_get_delegate(pan_position_min_get);
 357         if (methods.FirstOrDefault(m => m.Name == "GetPanPositionMin") != null)
 358             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)});
 359         if (efl_ui_pan_position_max_get_static_delegate == null)
 360             efl_ui_pan_position_max_get_static_delegate = new efl_ui_pan_position_max_get_delegate(pan_position_max_get);
 361         if (methods.FirstOrDefault(m => m.Name == "GetPanPositionMax") != null)
 362             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)});
 363         if (efl_content_get_static_delegate == null)
 364             efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 365         if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
 366             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)});
 367         if (efl_content_set_static_delegate == null)
 368             efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 369         if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
 370             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)});
 371         if (efl_content_unset_static_delegate == null)
 372             efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 373         if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
 374             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)});
 375         descs.AddRange(base.GetEoOps(type));
 376         return descs;
 377     }
 378     public override IntPtr GetEflClass()
 379     {
 380         return Efl.Ui.Pan.efl_ui_pan_class_get();
 381     }
 382     public static new  IntPtr GetEflClassStatic()
 383     {
 384         return Efl.Ui.Pan.efl_ui_pan_class_get();
 385     }
 386
 387
 388      private delegate Eina.Position2D.NativeStruct efl_ui_pan_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
 389
 390
 391      public delegate Eina.Position2D.NativeStruct efl_ui_pan_position_get_api_delegate(System.IntPtr obj);
 392      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");
 393      private static Eina.Position2D.NativeStruct pan_position_get(System.IntPtr obj, System.IntPtr pd)
 394     {
 395         Eina.Log.Debug("function efl_ui_pan_position_get was called");
 396         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 397         if(wrapper != null) {
 398                         Eina.Position2D _ret_var = default(Eina.Position2D);
 399             try {
 400                 _ret_var = ((Pan)wrapper).GetPanPosition();
 401             } catch (Exception e) {
 402                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 403                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 404             }
 405         return _ret_var;
 406         } else {
 407             return efl_ui_pan_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 408         }
 409     }
 410     private static efl_ui_pan_position_get_delegate efl_ui_pan_position_get_static_delegate;
 411
 412
 413      private delegate void efl_ui_pan_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Position2D.NativeStruct position);
 414
 415
 416      public delegate void efl_ui_pan_position_set_api_delegate(System.IntPtr obj,   Eina.Position2D.NativeStruct position);
 417      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");
 418      private static void pan_position_set(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct position)
 419     {
 420         Eina.Log.Debug("function efl_ui_pan_position_set was called");
 421         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 422         if(wrapper != null) {
 423                     Eina.Position2D _in_position = position;
 424
 425             try {
 426                 ((Pan)wrapper).SetPanPosition( _in_position);
 427             } catch (Exception e) {
 428                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 429                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 430             }
 431                                 } else {
 432             efl_ui_pan_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  position);
 433         }
 434     }
 435     private static efl_ui_pan_position_set_delegate efl_ui_pan_position_set_static_delegate;
 436
 437
 438      private delegate Eina.Size2D.NativeStruct efl_ui_pan_content_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 439
 440
 441      public delegate Eina.Size2D.NativeStruct efl_ui_pan_content_size_get_api_delegate(System.IntPtr obj);
 442      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");
 443      private static Eina.Size2D.NativeStruct content_size_get(System.IntPtr obj, System.IntPtr pd)
 444     {
 445         Eina.Log.Debug("function efl_ui_pan_content_size_get was called");
 446         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 447         if(wrapper != null) {
 448                         Eina.Size2D _ret_var = default(Eina.Size2D);
 449             try {
 450                 _ret_var = ((Pan)wrapper).GetContentSize();
 451             } catch (Exception e) {
 452                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 453                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 454             }
 455         return _ret_var;
 456         } else {
 457             return efl_ui_pan_content_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 458         }
 459     }
 460     private static efl_ui_pan_content_size_get_delegate efl_ui_pan_content_size_get_static_delegate;
 461
 462
 463      private delegate Eina.Position2D.NativeStruct efl_ui_pan_position_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 464
 465
 466      public delegate Eina.Position2D.NativeStruct efl_ui_pan_position_min_get_api_delegate(System.IntPtr obj);
 467      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");
 468      private static Eina.Position2D.NativeStruct pan_position_min_get(System.IntPtr obj, System.IntPtr pd)
 469     {
 470         Eina.Log.Debug("function efl_ui_pan_position_min_get was called");
 471         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 472         if(wrapper != null) {
 473                         Eina.Position2D _ret_var = default(Eina.Position2D);
 474             try {
 475                 _ret_var = ((Pan)wrapper).GetPanPositionMin();
 476             } catch (Exception e) {
 477                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 478                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 479             }
 480         return _ret_var;
 481         } else {
 482             return efl_ui_pan_position_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 483         }
 484     }
 485     private static efl_ui_pan_position_min_get_delegate efl_ui_pan_position_min_get_static_delegate;
 486
 487
 488      private delegate Eina.Position2D.NativeStruct efl_ui_pan_position_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 489
 490
 491      public delegate Eina.Position2D.NativeStruct efl_ui_pan_position_max_get_api_delegate(System.IntPtr obj);
 492      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");
 493      private static Eina.Position2D.NativeStruct pan_position_max_get(System.IntPtr obj, System.IntPtr pd)
 494     {
 495         Eina.Log.Debug("function efl_ui_pan_position_max_get was called");
 496         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 497         if(wrapper != null) {
 498                         Eina.Position2D _ret_var = default(Eina.Position2D);
 499             try {
 500                 _ret_var = ((Pan)wrapper).GetPanPositionMax();
 501             } catch (Exception e) {
 502                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 503                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 504             }
 505         return _ret_var;
 506         } else {
 507             return efl_ui_pan_position_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 508         }
 509     }
 510     private static efl_ui_pan_position_max_get_delegate efl_ui_pan_position_max_get_static_delegate;
 511
 512
 513     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
 514
 515
 516     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
 517      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");
 518      private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
 519     {
 520         Eina.Log.Debug("function efl_content_get was called");
 521         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 522         if(wrapper != null) {
 523                         Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 524             try {
 525                 _ret_var = ((Pan)wrapper).GetContent();
 526             } catch (Exception e) {
 527                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 528                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 529             }
 530         return _ret_var;
 531         } else {
 532             return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 533         }
 534     }
 535     private static efl_content_get_delegate efl_content_get_static_delegate;
 536
 537
 538      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity content);
 539
 540
 541      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity content);
 542      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");
 543      private static bool content_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IEntity content)
 544     {
 545         Eina.Log.Debug("function efl_content_set was called");
 546         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 547         if(wrapper != null) {
 548                                                 bool _ret_var = default(bool);
 549             try {
 550                 _ret_var = ((Pan)wrapper).SetContent( content);
 551             } catch (Exception e) {
 552                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 553                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 554             }
 555                         return _ret_var;
 556         } else {
 557             return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  content);
 558         }
 559     }
 560     private static efl_content_set_delegate efl_content_set_static_delegate;
 561
 562
 563     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
 564
 565
 566     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
 567      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");
 568      private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
 569     {
 570         Eina.Log.Debug("function efl_content_unset was called");
 571         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 572         if(wrapper != null) {
 573                         Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 574             try {
 575                 _ret_var = ((Pan)wrapper).UnsetContent();
 576             } catch (Exception e) {
 577                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 578                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 579             }
 580         return _ret_var;
 581         } else {
 582             return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 583         }
 584     }
 585     private static efl_content_unset_delegate efl_content_unset_static_delegate;
 586 }
 587 } }