internals/src/EflSharp/EflSharp/efl/efl_app.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 /// <summary>Object representing the application itself.
  11 /// (Since EFL 1.22)</summary>
  12 [Efl.App.NativeMethods]
  13 public abstract class App : Efl.Loop, Efl.Core.ICommandLine
  14 {
  15     ///<summary>Pointer to the native class description.</summary>
  16     public override System.IntPtr NativeClass
  17     {
  18         get
  19         {
  20             if (((object)this).GetType() == typeof(App))
  21             {
  22                 return GetEflClassStatic();
  23             }
  24             else
  25             {
  26                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  27             }
  28         }
  29     }
  30
  31     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  32         efl_app_class_get();
  33     /// <summary>Initializes a new instance of the <see cref="App"/> class.</summary>
  34     /// <param name="parent">Parent instance.</param>
  35     public App(Efl.Object parent= null
  36             ) : base(efl_app_class_get(), typeof(App), parent)
  37     {
  38         FinishInstantiation();
  39     }
  40
  41     /// <summary>Initializes a new instance of the <see cref="App"/> class.
  42     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  43     /// <param name="raw">The native pointer to be wrapped.</param>
  44     protected App(System.IntPtr raw) : base(raw)
  45     {
  46     }
  47
  48     [Efl.Eo.PrivateNativeClass]
  49     private class AppRealized : App
  50     {
  51         private AppRealized(IntPtr ptr) : base(ptr)
  52         {
  53         }
  54     }
  55     /// <summary>Initializes a new instance of the <see cref="App"/> class.
  56     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  57     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  58     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected App(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  61     {
  62     }
  63
  64     /// <summary>Called when the application is not going be displayed or otherwise used by a user for some time
  65     /// (Since EFL 1.22)</summary>
  66     public event EventHandler PauseEvt
  67     {
  68         add
  69         {
  70             lock (eventLock)
  71             {
  72                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  73                 {
  74                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  75                     if (obj != null)
  76                     {
  77                         EventArgs args = EventArgs.Empty;
  78                         try
  79                         {
  80                             value?.Invoke(obj, args);
  81                         }
  82                         catch (Exception e)
  83                         {
  84                             Eina.Log.Error(e.ToString());
  85                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  86                         }
  87                     }
  88                 };
  89
  90                 string key = "_EFL_APP_EVENT_PAUSE";
  91                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
  92             }
  93         }
  94
  95         remove
  96         {
  97             lock (eventLock)
  98             {
  99                 string key = "_EFL_APP_EVENT_PAUSE";
 100                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 101             }
 102         }
 103     }
 104     ///<summary>Method to raise event PauseEvt.</summary>
 105     public void OnPauseEvt(EventArgs e)
 106     {
 107         var key = "_EFL_APP_EVENT_PAUSE";
 108         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 109         if (desc == IntPtr.Zero)
 110         {
 111             Eina.Log.Error($"Failed to get native event {key}");
 112             return;
 113         }
 114
 115         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 116     }
 117     /// <summary>Called before a window is rendered after a pause event
 118     /// (Since EFL 1.22)</summary>
 119     public event EventHandler ResumeEvt
 120     {
 121         add
 122         {
 123             lock (eventLock)
 124             {
 125                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 126                 {
 127                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 128                     if (obj != null)
 129                     {
 130                         EventArgs args = EventArgs.Empty;
 131                         try
 132                         {
 133                             value?.Invoke(obj, args);
 134                         }
 135                         catch (Exception e)
 136                         {
 137                             Eina.Log.Error(e.ToString());
 138                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 139                         }
 140                     }
 141                 };
 142
 143                 string key = "_EFL_APP_EVENT_RESUME";
 144                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 145             }
 146         }
 147
 148         remove
 149         {
 150             lock (eventLock)
 151             {
 152                 string key = "_EFL_APP_EVENT_RESUME";
 153                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 154             }
 155         }
 156     }
 157     ///<summary>Method to raise event ResumeEvt.</summary>
 158     public void OnResumeEvt(EventArgs e)
 159     {
 160         var key = "_EFL_APP_EVENT_RESUME";
 161         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 162         if (desc == IntPtr.Zero)
 163         {
 164             Eina.Log.Error($"Failed to get native event {key}");
 165             return;
 166         }
 167
 168         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 169     }
 170     /// <summary>Called when the application&apos;s windows are all destroyed
 171     /// (Since EFL 1.22)</summary>
 172     public event EventHandler StandbyEvt
 173     {
 174         add
 175         {
 176             lock (eventLock)
 177             {
 178                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 179                 {
 180                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 181                     if (obj != null)
 182                     {
 183                         EventArgs args = EventArgs.Empty;
 184                         try
 185                         {
 186                             value?.Invoke(obj, args);
 187                         }
 188                         catch (Exception e)
 189                         {
 190                             Eina.Log.Error(e.ToString());
 191                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 192                         }
 193                     }
 194                 };
 195
 196                 string key = "_EFL_APP_EVENT_STANDBY";
 197                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 198             }
 199         }
 200
 201         remove
 202         {
 203             lock (eventLock)
 204             {
 205                 string key = "_EFL_APP_EVENT_STANDBY";
 206                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 207             }
 208         }
 209     }
 210     ///<summary>Method to raise event StandbyEvt.</summary>
 211     public void OnStandbyEvt(EventArgs e)
 212     {
 213         var key = "_EFL_APP_EVENT_STANDBY";
 214         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 215         if (desc == IntPtr.Zero)
 216         {
 217             Eina.Log.Error($"Failed to get native event {key}");
 218             return;
 219         }
 220
 221         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 222     }
 223     /// <summary>Called before starting the shutdown of the application
 224     /// (Since EFL 1.22)</summary>
 225     public event EventHandler TerminateEvt
 226     {
 227         add
 228         {
 229             lock (eventLock)
 230             {
 231                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 232                 {
 233                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 234                     if (obj != null)
 235                     {
 236                         EventArgs args = EventArgs.Empty;
 237                         try
 238                         {
 239                             value?.Invoke(obj, args);
 240                         }
 241                         catch (Exception e)
 242                         {
 243                             Eina.Log.Error(e.ToString());
 244                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 245                         }
 246                     }
 247                 };
 248
 249                 string key = "_EFL_APP_EVENT_TERMINATE";
 250                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 251             }
 252         }
 253
 254         remove
 255         {
 256             lock (eventLock)
 257             {
 258                 string key = "_EFL_APP_EVENT_TERMINATE";
 259                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 260             }
 261         }
 262     }
 263     ///<summary>Method to raise event TerminateEvt.</summary>
 264     public void OnTerminateEvt(EventArgs e)
 265     {
 266         var key = "_EFL_APP_EVENT_TERMINATE";
 267         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 268         if (desc == IntPtr.Zero)
 269         {
 270             Eina.Log.Error($"Failed to get native event {key}");
 271             return;
 272         }
 273
 274         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 275     }
 276     /// <summary>System specific, but on unix maps to SIGUSR1 signal to the process - only called on main loop object
 277     /// (Since EFL 1.22)</summary>
 278     public event EventHandler SignalUsr1Evt
 279     {
 280         add
 281         {
 282             lock (eventLock)
 283             {
 284                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 285                 {
 286                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 287                     if (obj != null)
 288                     {
 289                         EventArgs args = EventArgs.Empty;
 290                         try
 291                         {
 292                             value?.Invoke(obj, args);
 293                         }
 294                         catch (Exception e)
 295                         {
 296                             Eina.Log.Error(e.ToString());
 297                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 298                         }
 299                     }
 300                 };
 301
 302                 string key = "_EFL_APP_EVENT_SIGNAL_USR1";
 303                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 304             }
 305         }
 306
 307         remove
 308         {
 309             lock (eventLock)
 310             {
 311                 string key = "_EFL_APP_EVENT_SIGNAL_USR1";
 312                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 313             }
 314         }
 315     }
 316     ///<summary>Method to raise event SignalUsr1Evt.</summary>
 317     public void OnSignalUsr1Evt(EventArgs e)
 318     {
 319         var key = "_EFL_APP_EVENT_SIGNAL_USR1";
 320         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 321         if (desc == IntPtr.Zero)
 322         {
 323             Eina.Log.Error($"Failed to get native event {key}");
 324             return;
 325         }
 326
 327         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 328     }
 329     /// <summary>System specific, but on unix maps to SIGUSR2 signal to the process - only called on main loop object
 330     /// (Since EFL 1.22)</summary>
 331     public event EventHandler SignalUsr2Evt
 332     {
 333         add
 334         {
 335             lock (eventLock)
 336             {
 337                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 338                 {
 339                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 340                     if (obj != null)
 341                     {
 342                         EventArgs args = EventArgs.Empty;
 343                         try
 344                         {
 345                             value?.Invoke(obj, args);
 346                         }
 347                         catch (Exception e)
 348                         {
 349                             Eina.Log.Error(e.ToString());
 350                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 351                         }
 352                     }
 353                 };
 354
 355                 string key = "_EFL_APP_EVENT_SIGNAL_USR2";
 356                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 357             }
 358         }
 359
 360         remove
 361         {
 362             lock (eventLock)
 363             {
 364                 string key = "_EFL_APP_EVENT_SIGNAL_USR2";
 365                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 366             }
 367         }
 368     }
 369     ///<summary>Method to raise event SignalUsr2Evt.</summary>
 370     public void OnSignalUsr2Evt(EventArgs e)
 371     {
 372         var key = "_EFL_APP_EVENT_SIGNAL_USR2";
 373         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 374         if (desc == IntPtr.Zero)
 375         {
 376             Eina.Log.Error($"Failed to get native event {key}");
 377             return;
 378         }
 379
 380         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 381     }
 382     /// <summary>System specific, but on unix maps to SIGHUP signal to the process - only called on main loop object
 383     /// (Since EFL 1.22)</summary>
 384     public event EventHandler SignalHupEvt
 385     {
 386         add
 387         {
 388             lock (eventLock)
 389             {
 390                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 391                 {
 392                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 393                     if (obj != null)
 394                     {
 395                         EventArgs args = EventArgs.Empty;
 396                         try
 397                         {
 398                             value?.Invoke(obj, args);
 399                         }
 400                         catch (Exception e)
 401                         {
 402                             Eina.Log.Error(e.ToString());
 403                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 404                         }
 405                     }
 406                 };
 407
 408                 string key = "_EFL_APP_EVENT_SIGNAL_HUP";
 409                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 410             }
 411         }
 412
 413         remove
 414         {
 415             lock (eventLock)
 416             {
 417                 string key = "_EFL_APP_EVENT_SIGNAL_HUP";
 418                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 419             }
 420         }
 421     }
 422     ///<summary>Method to raise event SignalHupEvt.</summary>
 423     public void OnSignalHupEvt(EventArgs e)
 424     {
 425         var key = "_EFL_APP_EVENT_SIGNAL_HUP";
 426         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 427         if (desc == IntPtr.Zero)
 428         {
 429             Eina.Log.Error($"Failed to get native event {key}");
 430             return;
 431         }
 432
 433         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 434     }
 435     /// <summary>Returns the app object that is representing this process
 436     /// Note: This function call only works in the main loop thread of the process.
 437     /// (Since EFL 1.22)</summary>
 438     /// <returns>Application for this process</returns>
 439     public static Efl.App GetAppMain() {
 440          var _ret_var = Efl.App.NativeMethods.efl_app_main_get_ptr.Value.Delegate();
 441         Eina.Error.RaiseIfUnhandledException();
 442         return _ret_var;
 443  }
 444     /// <summary>Indicates the version of EFL with which this application was compiled against/for.
 445     /// This might differ from <see cref="Efl.App.GetEflVersion"/>.
 446     /// (Since EFL 1.22)</summary>
 447     /// <returns>Efl build version</returns>
 448     virtual public Efl.Version GetBuildEflVersion() {
 449          var _ret_var = Efl.App.NativeMethods.efl_app_build_efl_version_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 450         Eina.Error.RaiseIfUnhandledException();
 451         var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Version>(_ret_var);
 452
 453         return __ret_tmp;
 454  }
 455     /// <summary>Indicates the currently running version of EFL.
 456     /// This might differ from <see cref="Efl.App.GetBuildEflVersion"/>.
 457     /// (Since EFL 1.22)</summary>
 458     /// <returns>Efl version</returns>
 459     virtual public Efl.Version GetEflVersion() {
 460          var _ret_var = Efl.App.NativeMethods.efl_app_efl_version_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 461         Eina.Error.RaiseIfUnhandledException();
 462         var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Version>(_ret_var);
 463
 464         return __ret_tmp;
 465  }
 466     /// <summary>A commandline that encodes arguments in a command string. This command is unix shell-style, thus whitespace separates arguments unless escaped. Also a semi-colon &apos;;&apos;, ampersand &apos;&amp;&apos;, pipe/bar &apos;|&apos;, hash &apos;#&apos;, bracket, square brace, brace character (&apos;(&apos;, &apos;)&apos;, &apos;[&apos;, &apos;]&apos;, &apos;{&apos;, &apos;}&apos;), exclamation mark &apos;!&apos;,  backquote &apos;`&apos;, greator or less than (&apos;&gt;&apos; &apos;&lt;&apos;) character unless escaped or in quotes would cause args_count/value to not be generated properly, because it would force complex shell interpretation which will not be supported in evaluating the arg_count/value information, but the final shell may interpret this if this is executed via a command-line shell. To not be a complex shell command, it should be simple with paths, options and variable expansions, but nothing more complex involving the above unescaped characters.
 467     /// &quot;cat -option /path/file&quot; &quot;cat &apos;quoted argument&apos;&quot; &quot;cat ~/path/escaped argument&quot; &quot;/bin/cat escaped argument <c>VARIABLE</c>&quot; etc.
 468     ///
 469     /// It should not try and use &quot;complex shell features&quot; if you want the arg_count and arg_value set to be correct after setting the command string. For example none of:
 470     ///
 471     /// &quot;VAR=x /bin/command &amp;&amp; /bin/othercommand &gt;&amp; /dev/null&quot; &quot;VAR=x /bin/command `/bin/othercommand` | /bin/cmd2 &amp;&amp; cmd3 &amp;&quot; etc.
 472     ///
 473     /// If you set the command the arg_count/value property contents can change and be completely re-evaluated by parsing the command string into an argument array set along with interpreting escapes back into individual argument strings.</summary>
 474     virtual public System.String GetCommand() {
 475          var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 476         Eina.Error.RaiseIfUnhandledException();
 477         return _ret_var;
 478  }
 479     /// <summary>Use an array to fill this object
 480     /// Every element of a string is a argument.</summary>
 481     /// <param name="array">An array where every array field is an argument</param>
 482     /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 483     virtual public bool SetCommandArray(Eina.Array<System.String> array) {
 484          var _in_array = array.Handle;
 485 array.Own = false;
 486 array.OwnContent = false;
 487                         var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_array_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_array);
 488         Eina.Error.RaiseIfUnhandledException();
 489                         return _ret_var;
 490  }
 491     /// <summary>Use a string to fill this object
 492     /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 493     /// <param name="str">A command in form of a string</param>
 494     /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 495     virtual public bool SetCommandString(System.String str) {
 496                                  var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),str);
 497         Eina.Error.RaiseIfUnhandledException();
 498                         return _ret_var;
 499  }
 500     /// <summary>Get the accessor which enables access to each argument that got passed to this object.</summary>
 501     virtual public Eina.Accessor<System.String> CommandAccess() {
 502          var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_access_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 503         Eina.Error.RaiseIfUnhandledException();
 504         return new Eina.Accessor<System.String>(_ret_var, false, false);
 505  }
 506     /// <summary>Returns the app object that is representing this process
 507     /// Note: This function call only works in the main loop thread of the process.
 508     /// (Since EFL 1.22)</summary>
 509     /// <value>Application for this process</value>
 510     public static Efl.App AppMain {
 511         get { return GetAppMain(); }
 512     }
 513     /// <summary>Indicates the version of EFL with which this application was compiled against/for.
 514     /// This might differ from <see cref="Efl.App.GetEflVersion"/>.
 515     /// (Since EFL 1.22)</summary>
 516     /// <value>Efl build version</value>
 517     public Efl.Version BuildEflVersion {
 518         get { return GetBuildEflVersion(); }
 519     }
 520     /// <summary>Indicates the currently running version of EFL.
 521     /// This might differ from <see cref="Efl.App.GetBuildEflVersion"/>.
 522     /// (Since EFL 1.22)</summary>
 523     /// <value>Efl version</value>
 524     public Efl.Version EflVersion {
 525         get { return GetEflVersion(); }
 526     }
 527     /// <summary>A commandline that encodes arguments in a command string. This command is unix shell-style, thus whitespace separates arguments unless escaped. Also a semi-colon &apos;;&apos;, ampersand &apos;&amp;&apos;, pipe/bar &apos;|&apos;, hash &apos;#&apos;, bracket, square brace, brace character (&apos;(&apos;, &apos;)&apos;, &apos;[&apos;, &apos;]&apos;, &apos;{&apos;, &apos;}&apos;), exclamation mark &apos;!&apos;,  backquote &apos;`&apos;, greator or less than (&apos;&gt;&apos; &apos;&lt;&apos;) character unless escaped or in quotes would cause args_count/value to not be generated properly, because it would force complex shell interpretation which will not be supported in evaluating the arg_count/value information, but the final shell may interpret this if this is executed via a command-line shell. To not be a complex shell command, it should be simple with paths, options and variable expansions, but nothing more complex involving the above unescaped characters.
 528     /// &quot;cat -option /path/file&quot; &quot;cat &apos;quoted argument&apos;&quot; &quot;cat ~/path/escaped argument&quot; &quot;/bin/cat escaped argument <c>VARIABLE</c>&quot; etc.
 529     ///
 530     /// It should not try and use &quot;complex shell features&quot; if you want the arg_count and arg_value set to be correct after setting the command string. For example none of:
 531     ///
 532     /// &quot;VAR=x /bin/command &amp;&amp; /bin/othercommand &gt;&amp; /dev/null&quot; &quot;VAR=x /bin/command `/bin/othercommand` | /bin/cmd2 &amp;&amp; cmd3 &amp;&quot; etc.
 533     ///
 534     /// If you set the command the arg_count/value property contents can change and be completely re-evaluated by parsing the command string into an argument array set along with interpreting escapes back into individual argument strings.</summary>
 535     public System.String Command {
 536         get { return GetCommand(); }
 537     }
 538     /// <summary>Use an array to fill this object
 539     /// Every element of a string is a argument.</summary>
 540     /// <value>An array where every array field is an argument</value>
 541     public Eina.Array<System.String> CommandArray {
 542         set { SetCommandArray(value); }
 543     }
 544     /// <summary>Use a string to fill this object
 545     /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 546     /// <value>A command in form of a string</value>
 547     public System.String CommandString {
 548         set { SetCommandString(value); }
 549     }
 550     private static IntPtr GetEflClassStatic()
 551     {
 552         return Efl.App.efl_app_class_get();
 553     }
 554     /// <summary>Wrapper for native methods and virtual method delegates.
 555     /// For internal use by generated code only.</summary>
 556     public new class NativeMethods : Efl.Loop.NativeMethods
 557     {
 558         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Ecore);
 559         /// <summary>Gets the list of Eo operations to override.</summary>
 560         /// <returns>The list of Eo operations to be overload.</returns>
 561         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 562         {
 563             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 564             var methods = Efl.Eo.Globals.GetUserMethods(type);
 565
 566             if (efl_app_build_efl_version_get_static_delegate == null)
 567             {
 568                 efl_app_build_efl_version_get_static_delegate = new efl_app_build_efl_version_get_delegate(build_efl_version_get);
 569             }
 570
 571             if (methods.FirstOrDefault(m => m.Name == "GetBuildEflVersion") != null)
 572             {
 573                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_app_build_efl_version_get"), func = Marshal.GetFunctionPointerForDelegate(efl_app_build_efl_version_get_static_delegate) });
 574             }
 575
 576             if (efl_app_efl_version_get_static_delegate == null)
 577             {
 578                 efl_app_efl_version_get_static_delegate = new efl_app_efl_version_get_delegate(efl_version_get);
 579             }
 580
 581             if (methods.FirstOrDefault(m => m.Name == "GetEflVersion") != null)
 582             {
 583                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_app_efl_version_get"), func = Marshal.GetFunctionPointerForDelegate(efl_app_efl_version_get_static_delegate) });
 584             }
 585
 586             if (efl_core_command_line_command_get_static_delegate == null)
 587             {
 588                 efl_core_command_line_command_get_static_delegate = new efl_core_command_line_command_get_delegate(command_get);
 589             }
 590
 591             if (methods.FirstOrDefault(m => m.Name == "GetCommand") != null)
 592             {
 593                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_get"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_get_static_delegate) });
 594             }
 595
 596             if (efl_core_command_line_command_array_set_static_delegate == null)
 597             {
 598                 efl_core_command_line_command_array_set_static_delegate = new efl_core_command_line_command_array_set_delegate(command_array_set);
 599             }
 600
 601             if (methods.FirstOrDefault(m => m.Name == "SetCommandArray") != null)
 602             {
 603                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_array_set"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_array_set_static_delegate) });
 604             }
 605
 606             if (efl_core_command_line_command_string_set_static_delegate == null)
 607             {
 608                 efl_core_command_line_command_string_set_static_delegate = new efl_core_command_line_command_string_set_delegate(command_string_set);
 609             }
 610
 611             if (methods.FirstOrDefault(m => m.Name == "SetCommandString") != null)
 612             {
 613                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_string_set_static_delegate) });
 614             }
 615
 616             if (efl_core_command_line_command_access_static_delegate == null)
 617             {
 618                 efl_core_command_line_command_access_static_delegate = new efl_core_command_line_command_access_delegate(command_access);
 619             }
 620
 621             if (methods.FirstOrDefault(m => m.Name == "CommandAccess") != null)
 622             {
 623                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_access"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_access_static_delegate) });
 624             }
 625
 626             descs.AddRange(base.GetEoOps(type));
 627             return descs;
 628         }
 629         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 630         /// <returns>The native class pointer.</returns>
 631         public override IntPtr GetEflClass()
 632         {
 633             return Efl.App.efl_app_class_get();
 634         }
 635
 636         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 637
 638         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 639         private delegate Efl.App efl_app_main_get_delegate();
 640
 641         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 642         public delegate Efl.App efl_app_main_get_api_delegate();
 643
 644         public static Efl.Eo.FunctionWrapper<efl_app_main_get_api_delegate> efl_app_main_get_ptr = new Efl.Eo.FunctionWrapper<efl_app_main_get_api_delegate>(Module, "efl_app_main_get");
 645
 646         private static Efl.App app_main_get(System.IntPtr obj, System.IntPtr pd)
 647         {
 648             Eina.Log.Debug("function efl_app_main_get was called");
 649             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 650             if (ws != null)
 651             {
 652             Efl.App _ret_var = default(Efl.App);
 653                 try
 654                 {
 655                     _ret_var = App.GetAppMain();
 656                 }
 657                 catch (Exception e)
 658                 {
 659                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 660                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 661                 }
 662
 663         return _ret_var;
 664
 665             }
 666             else
 667             {
 668                 return efl_app_main_get_ptr.Value.Delegate();
 669             }
 670         }
 671
 672
 673         private delegate System.IntPtr efl_app_build_efl_version_get_delegate(System.IntPtr obj, System.IntPtr pd);
 674
 675
 676         public delegate System.IntPtr efl_app_build_efl_version_get_api_delegate(System.IntPtr obj);
 677
 678         public static Efl.Eo.FunctionWrapper<efl_app_build_efl_version_get_api_delegate> efl_app_build_efl_version_get_ptr = new Efl.Eo.FunctionWrapper<efl_app_build_efl_version_get_api_delegate>(Module, "efl_app_build_efl_version_get");
 679
 680         private static System.IntPtr build_efl_version_get(System.IntPtr obj, System.IntPtr pd)
 681         {
 682             Eina.Log.Debug("function efl_app_build_efl_version_get was called");
 683             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 684             if (ws != null)
 685             {
 686             Efl.Version _ret_var = default(Efl.Version);
 687                 try
 688                 {
 689                     _ret_var = ((App)ws.Target).GetBuildEflVersion();
 690                 }
 691                 catch (Exception e)
 692                 {
 693                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 694                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 695                 }
 696
 697         return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
 698
 699             }
 700             else
 701             {
 702                 return efl_app_build_efl_version_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 703             }
 704         }
 705
 706         private static efl_app_build_efl_version_get_delegate efl_app_build_efl_version_get_static_delegate;
 707
 708
 709         private delegate System.IntPtr efl_app_efl_version_get_delegate(System.IntPtr obj, System.IntPtr pd);
 710
 711
 712         public delegate System.IntPtr efl_app_efl_version_get_api_delegate(System.IntPtr obj);
 713
 714         public static Efl.Eo.FunctionWrapper<efl_app_efl_version_get_api_delegate> efl_app_efl_version_get_ptr = new Efl.Eo.FunctionWrapper<efl_app_efl_version_get_api_delegate>(Module, "efl_app_efl_version_get");
 715
 716         private static System.IntPtr efl_version_get(System.IntPtr obj, System.IntPtr pd)
 717         {
 718             Eina.Log.Debug("function efl_app_efl_version_get was called");
 719             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 720             if (ws != null)
 721             {
 722             Efl.Version _ret_var = default(Efl.Version);
 723                 try
 724                 {
 725                     _ret_var = ((App)ws.Target).GetEflVersion();
 726                 }
 727                 catch (Exception e)
 728                 {
 729                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 730                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 731                 }
 732
 733         return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
 734
 735             }
 736             else
 737             {
 738                 return efl_app_efl_version_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 739             }
 740         }
 741
 742         private static efl_app_efl_version_get_delegate efl_app_efl_version_get_static_delegate;
 743
 744         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 745         private delegate System.String efl_core_command_line_command_get_delegate(System.IntPtr obj, System.IntPtr pd);
 746
 747         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 748         public delegate System.String efl_core_command_line_command_get_api_delegate(System.IntPtr obj);
 749
 750         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_get_api_delegate> efl_core_command_line_command_get_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_get_api_delegate>(Module, "efl_core_command_line_command_get");
 751
 752         private static System.String command_get(System.IntPtr obj, System.IntPtr pd)
 753         {
 754             Eina.Log.Debug("function efl_core_command_line_command_get was called");
 755             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 756             if (ws != null)
 757             {
 758             System.String _ret_var = default(System.String);
 759                 try
 760                 {
 761                     _ret_var = ((App)ws.Target).GetCommand();
 762                 }
 763                 catch (Exception e)
 764                 {
 765                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 766                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 767                 }
 768
 769         return _ret_var;
 770
 771             }
 772             else
 773             {
 774                 return efl_core_command_line_command_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 775             }
 776         }
 777
 778         private static efl_core_command_line_command_get_delegate efl_core_command_line_command_get_static_delegate;
 779
 780         [return: MarshalAs(UnmanagedType.U1)]
 781         private delegate bool efl_core_command_line_command_array_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr array);
 782
 783         [return: MarshalAs(UnmanagedType.U1)]
 784         public delegate bool efl_core_command_line_command_array_set_api_delegate(System.IntPtr obj,  System.IntPtr array);
 785
 786         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_array_set_api_delegate> efl_core_command_line_command_array_set_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_array_set_api_delegate>(Module, "efl_core_command_line_command_array_set");
 787
 788         private static bool command_array_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr array)
 789         {
 790             Eina.Log.Debug("function efl_core_command_line_command_array_set was called");
 791             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 792             if (ws != null)
 793             {
 794         var _in_array = new Eina.Array<System.String>(array, true, true);
 795                             bool _ret_var = default(bool);
 796                 try
 797                 {
 798                     _ret_var = ((App)ws.Target).SetCommandArray(_in_array);
 799                 }
 800                 catch (Exception e)
 801                 {
 802                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 803                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 804                 }
 805
 806                         return _ret_var;
 807
 808             }
 809             else
 810             {
 811                 return efl_core_command_line_command_array_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), array);
 812             }
 813         }
 814
 815         private static efl_core_command_line_command_array_set_delegate efl_core_command_line_command_array_set_static_delegate;
 816
 817         [return: MarshalAs(UnmanagedType.U1)]
 818         private delegate bool efl_core_command_line_command_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String str);
 819
 820         [return: MarshalAs(UnmanagedType.U1)]
 821         public delegate bool efl_core_command_line_command_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String str);
 822
 823         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_string_set_api_delegate> efl_core_command_line_command_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_string_set_api_delegate>(Module, "efl_core_command_line_command_string_set");
 824
 825         private static bool command_string_set(System.IntPtr obj, System.IntPtr pd, System.String str)
 826         {
 827             Eina.Log.Debug("function efl_core_command_line_command_string_set was called");
 828             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 829             if (ws != null)
 830             {
 831                                     bool _ret_var = default(bool);
 832                 try
 833                 {
 834                     _ret_var = ((App)ws.Target).SetCommandString(str);
 835                 }
 836                 catch (Exception e)
 837                 {
 838                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 839                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 840                 }
 841
 842                         return _ret_var;
 843
 844             }
 845             else
 846             {
 847                 return efl_core_command_line_command_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), str);
 848             }
 849         }
 850
 851         private static efl_core_command_line_command_string_set_delegate efl_core_command_line_command_string_set_static_delegate;
 852
 853
 854         private delegate System.IntPtr efl_core_command_line_command_access_delegate(System.IntPtr obj, System.IntPtr pd);
 855
 856
 857         public delegate System.IntPtr efl_core_command_line_command_access_api_delegate(System.IntPtr obj);
 858
 859         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_access_api_delegate> efl_core_command_line_command_access_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_access_api_delegate>(Module, "efl_core_command_line_command_access");
 860
 861         private static System.IntPtr command_access(System.IntPtr obj, System.IntPtr pd)
 862         {
 863             Eina.Log.Debug("function efl_core_command_line_command_access was called");
 864             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 865             if (ws != null)
 866             {
 867             Eina.Accessor<System.String> _ret_var = default(Eina.Accessor<System.String>);
 868                 try
 869                 {
 870                     _ret_var = ((App)ws.Target).CommandAccess();
 871                 }
 872                 catch (Exception e)
 873                 {
 874                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 875                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 876                 }
 877
 878         return _ret_var.Handle;
 879
 880             }
 881             else
 882             {
 883                 return efl_core_command_line_command_access_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 884             }
 885         }
 886
 887         private static efl_core_command_line_command_access_delegate efl_core_command_line_command_access_static_delegate;
 888
 889         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 890
 891 }
 892 }
 893 }
 894