internals/src/EflSharp/EflSharp/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.ComponentModel;
   7 namespace Efl {
   8 /// <summary>Object representing the application itself</summary>
   9 [AppNativeInherit]
  10 public class App : Efl.Loop, Efl.Eo.IWrapper,Efl.Core.CommandLine
  11 {
  12    public new static System.IntPtr klass = System.IntPtr.Zero;
  13    public new static Efl.AppNativeInherit nativeInherit = new Efl.AppNativeInherit();
  14    ///<summary>Pointer to the native class description.</summary>
  15    public override System.IntPtr NativeClass {
  16       get {
  17          if (((object)this).GetType() == typeof (App))
  18             return Efl.AppNativeInherit.GetEflClassStatic();
  19          else
  20             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  21       }
  22    }
  23    [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  24       efl_app_class_get();
  25    ///<summary>Creates a new instance.</summary>
  26    ///<param name="parent">Parent instance.</param>
  27    public App(Efl.Object parent= null
  28          ) :
  29       base(efl_app_class_get(), typeof(App), parent)
  30    {
  31       FinishInstantiation();
  32    }
  33    ///<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>
  34    public App(System.IntPtr raw) : base(raw)
  35    {
  36             register_event_proxies();
  37    }
  38    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  39    protected App(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  40    ///<summary>Casts obj into an instance of this type.</summary>
  41    public new static App static_cast(Efl.Object obj)
  42    {
  43       if (obj == null)
  44          throw new System.ArgumentNullException("obj");
  45       return new App(obj.NativeHandle);
  46    }
  47    ///<summary>Verifies if the given object is equal to this one.</summary>
  48    public override bool Equals(object obj)
  49    {
  50       var other = obj as Efl.Object;
  51       if (other == null)
  52          return false;
  53       return this.NativeHandle == other.NativeHandle;
  54    }
  55    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  56    public override int GetHashCode()
  57    {
  58       return this.NativeHandle.ToInt32();
  59    }
  60    ///<summary>Turns the native pointer into a string representation.</summary>
  61    public override String ToString()
  62    {
  63       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  64    }
  65 private static object PauseEvtKey = new object();
  66    /// <summary>Called when the application is not going be displayed or otherwise used by a user for some time</summary>
  67    public event EventHandler PauseEvt
  68    {
  69       add {
  70          lock (eventLock) {
  71             string key = "_EFL_APP_EVENT_PAUSE";
  72             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_PauseEvt_delegate)) {
  73                eventHandlers.AddHandler(PauseEvtKey , value);
  74             } else
  75                Eina.Log.Error($"Error adding proxy for event {key}");
  76          }
  77       }
  78       remove {
  79          lock (eventLock) {
  80             string key = "_EFL_APP_EVENT_PAUSE";
  81             if (remove_cpp_event_handler(key, this.evt_PauseEvt_delegate)) {
  82                eventHandlers.RemoveHandler(PauseEvtKey , value);
  83             } else
  84                Eina.Log.Error($"Error removing proxy for event {key}");
  85          }
  86       }
  87    }
  88    ///<summary>Method to raise event PauseEvt.</summary>
  89    public void On_PauseEvt(EventArgs e)
  90    {
  91       EventHandler evt;
  92       lock (eventLock) {
  93       evt = (EventHandler)eventHandlers[PauseEvtKey];
  94       }
  95       evt?.Invoke(this, e);
  96    }
  97    Efl.EventCb evt_PauseEvt_delegate;
  98    private void on_PauseEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
  99    {
 100       EventArgs args = EventArgs.Empty;
 101       try {
 102          On_PauseEvt(args);
 103       } catch (Exception e) {
 104          Eina.Log.Error(e.ToString());
 105          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 106       }
 107    }
 108
 109 private static object ResumeEvtKey = new object();
 110    /// <summary>Called before a window is rendered after a pause event</summary>
 111    public event EventHandler ResumeEvt
 112    {
 113       add {
 114          lock (eventLock) {
 115             string key = "_EFL_APP_EVENT_RESUME";
 116             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_ResumeEvt_delegate)) {
 117                eventHandlers.AddHandler(ResumeEvtKey , value);
 118             } else
 119                Eina.Log.Error($"Error adding proxy for event {key}");
 120          }
 121       }
 122       remove {
 123          lock (eventLock) {
 124             string key = "_EFL_APP_EVENT_RESUME";
 125             if (remove_cpp_event_handler(key, this.evt_ResumeEvt_delegate)) {
 126                eventHandlers.RemoveHandler(ResumeEvtKey , value);
 127             } else
 128                Eina.Log.Error($"Error removing proxy for event {key}");
 129          }
 130       }
 131    }
 132    ///<summary>Method to raise event ResumeEvt.</summary>
 133    public void On_ResumeEvt(EventArgs e)
 134    {
 135       EventHandler evt;
 136       lock (eventLock) {
 137       evt = (EventHandler)eventHandlers[ResumeEvtKey];
 138       }
 139       evt?.Invoke(this, e);
 140    }
 141    Efl.EventCb evt_ResumeEvt_delegate;
 142    private void on_ResumeEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 143    {
 144       EventArgs args = EventArgs.Empty;
 145       try {
 146          On_ResumeEvt(args);
 147       } catch (Exception e) {
 148          Eina.Log.Error(e.ToString());
 149          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 150       }
 151    }
 152
 153 private static object StandbyEvtKey = new object();
 154    /// <summary>Called when the application&apos;s windows are all destroyed</summary>
 155    public event EventHandler StandbyEvt
 156    {
 157       add {
 158          lock (eventLock) {
 159             string key = "_EFL_APP_EVENT_STANDBY";
 160             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_StandbyEvt_delegate)) {
 161                eventHandlers.AddHandler(StandbyEvtKey , value);
 162             } else
 163                Eina.Log.Error($"Error adding proxy for event {key}");
 164          }
 165       }
 166       remove {
 167          lock (eventLock) {
 168             string key = "_EFL_APP_EVENT_STANDBY";
 169             if (remove_cpp_event_handler(key, this.evt_StandbyEvt_delegate)) {
 170                eventHandlers.RemoveHandler(StandbyEvtKey , value);
 171             } else
 172                Eina.Log.Error($"Error removing proxy for event {key}");
 173          }
 174       }
 175    }
 176    ///<summary>Method to raise event StandbyEvt.</summary>
 177    public void On_StandbyEvt(EventArgs e)
 178    {
 179       EventHandler evt;
 180       lock (eventLock) {
 181       evt = (EventHandler)eventHandlers[StandbyEvtKey];
 182       }
 183       evt?.Invoke(this, e);
 184    }
 185    Efl.EventCb evt_StandbyEvt_delegate;
 186    private void on_StandbyEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 187    {
 188       EventArgs args = EventArgs.Empty;
 189       try {
 190          On_StandbyEvt(args);
 191       } catch (Exception e) {
 192          Eina.Log.Error(e.ToString());
 193          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 194       }
 195    }
 196
 197 private static object TerminateEvtKey = new object();
 198    /// <summary>Called before starting the shutdown of the application</summary>
 199    public event EventHandler TerminateEvt
 200    {
 201       add {
 202          lock (eventLock) {
 203             string key = "_EFL_APP_EVENT_TERMINATE";
 204             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_TerminateEvt_delegate)) {
 205                eventHandlers.AddHandler(TerminateEvtKey , value);
 206             } else
 207                Eina.Log.Error($"Error adding proxy for event {key}");
 208          }
 209       }
 210       remove {
 211          lock (eventLock) {
 212             string key = "_EFL_APP_EVENT_TERMINATE";
 213             if (remove_cpp_event_handler(key, this.evt_TerminateEvt_delegate)) {
 214                eventHandlers.RemoveHandler(TerminateEvtKey , value);
 215             } else
 216                Eina.Log.Error($"Error removing proxy for event {key}");
 217          }
 218       }
 219    }
 220    ///<summary>Method to raise event TerminateEvt.</summary>
 221    public void On_TerminateEvt(EventArgs e)
 222    {
 223       EventHandler evt;
 224       lock (eventLock) {
 225       evt = (EventHandler)eventHandlers[TerminateEvtKey];
 226       }
 227       evt?.Invoke(this, e);
 228    }
 229    Efl.EventCb evt_TerminateEvt_delegate;
 230    private void on_TerminateEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 231    {
 232       EventArgs args = EventArgs.Empty;
 233       try {
 234          On_TerminateEvt(args);
 235       } catch (Exception e) {
 236          Eina.Log.Error(e.ToString());
 237          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 238       }
 239    }
 240
 241 private static object SignalUsr1EvtKey = new object();
 242    /// <summary>System specific, but on unix maps to SIGUSR1 signal to the process - only called on main loop object</summary>
 243    public event EventHandler SignalUsr1Evt
 244    {
 245       add {
 246          lock (eventLock) {
 247             string key = "_EFL_APP_EVENT_SIGNAL_USR1";
 248             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_SignalUsr1Evt_delegate)) {
 249                eventHandlers.AddHandler(SignalUsr1EvtKey , value);
 250             } else
 251                Eina.Log.Error($"Error adding proxy for event {key}");
 252          }
 253       }
 254       remove {
 255          lock (eventLock) {
 256             string key = "_EFL_APP_EVENT_SIGNAL_USR1";
 257             if (remove_cpp_event_handler(key, this.evt_SignalUsr1Evt_delegate)) {
 258                eventHandlers.RemoveHandler(SignalUsr1EvtKey , value);
 259             } else
 260                Eina.Log.Error($"Error removing proxy for event {key}");
 261          }
 262       }
 263    }
 264    ///<summary>Method to raise event SignalUsr1Evt.</summary>
 265    public void On_SignalUsr1Evt(EventArgs e)
 266    {
 267       EventHandler evt;
 268       lock (eventLock) {
 269       evt = (EventHandler)eventHandlers[SignalUsr1EvtKey];
 270       }
 271       evt?.Invoke(this, e);
 272    }
 273    Efl.EventCb evt_SignalUsr1Evt_delegate;
 274    private void on_SignalUsr1Evt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 275    {
 276       EventArgs args = EventArgs.Empty;
 277       try {
 278          On_SignalUsr1Evt(args);
 279       } catch (Exception e) {
 280          Eina.Log.Error(e.ToString());
 281          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 282       }
 283    }
 284
 285 private static object SignalUsr2EvtKey = new object();
 286    /// <summary>System specific, but on unix maps to SIGUSR2 signal to the process - only called on main loop object</summary>
 287    public event EventHandler SignalUsr2Evt
 288    {
 289       add {
 290          lock (eventLock) {
 291             string key = "_EFL_APP_EVENT_SIGNAL_USR2";
 292             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_SignalUsr2Evt_delegate)) {
 293                eventHandlers.AddHandler(SignalUsr2EvtKey , value);
 294             } else
 295                Eina.Log.Error($"Error adding proxy for event {key}");
 296          }
 297       }
 298       remove {
 299          lock (eventLock) {
 300             string key = "_EFL_APP_EVENT_SIGNAL_USR2";
 301             if (remove_cpp_event_handler(key, this.evt_SignalUsr2Evt_delegate)) {
 302                eventHandlers.RemoveHandler(SignalUsr2EvtKey , value);
 303             } else
 304                Eina.Log.Error($"Error removing proxy for event {key}");
 305          }
 306       }
 307    }
 308    ///<summary>Method to raise event SignalUsr2Evt.</summary>
 309    public void On_SignalUsr2Evt(EventArgs e)
 310    {
 311       EventHandler evt;
 312       lock (eventLock) {
 313       evt = (EventHandler)eventHandlers[SignalUsr2EvtKey];
 314       }
 315       evt?.Invoke(this, e);
 316    }
 317    Efl.EventCb evt_SignalUsr2Evt_delegate;
 318    private void on_SignalUsr2Evt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 319    {
 320       EventArgs args = EventArgs.Empty;
 321       try {
 322          On_SignalUsr2Evt(args);
 323       } catch (Exception e) {
 324          Eina.Log.Error(e.ToString());
 325          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 326       }
 327    }
 328
 329 private static object SignalHupEvtKey = new object();
 330    /// <summary>System specific, but on unix maps to SIGHUP signal to the process - only called on main loop object</summary>
 331    public event EventHandler SignalHupEvt
 332    {
 333       add {
 334          lock (eventLock) {
 335             string key = "_EFL_APP_EVENT_SIGNAL_HUP";
 336             if (add_cpp_event_handler(efl.Libs.Ecore, key, this.evt_SignalHupEvt_delegate)) {
 337                eventHandlers.AddHandler(SignalHupEvtKey , value);
 338             } else
 339                Eina.Log.Error($"Error adding proxy for event {key}");
 340          }
 341       }
 342       remove {
 343          lock (eventLock) {
 344             string key = "_EFL_APP_EVENT_SIGNAL_HUP";
 345             if (remove_cpp_event_handler(key, this.evt_SignalHupEvt_delegate)) {
 346                eventHandlers.RemoveHandler(SignalHupEvtKey , value);
 347             } else
 348                Eina.Log.Error($"Error removing proxy for event {key}");
 349          }
 350       }
 351    }
 352    ///<summary>Method to raise event SignalHupEvt.</summary>
 353    public void On_SignalHupEvt(EventArgs e)
 354    {
 355       EventHandler evt;
 356       lock (eventLock) {
 357       evt = (EventHandler)eventHandlers[SignalHupEvtKey];
 358       }
 359       evt?.Invoke(this, e);
 360    }
 361    Efl.EventCb evt_SignalHupEvt_delegate;
 362    private void on_SignalHupEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 363    {
 364       EventArgs args = EventArgs.Empty;
 365       try {
 366          On_SignalHupEvt(args);
 367       } catch (Exception e) {
 368          Eina.Log.Error(e.ToString());
 369          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 370       }
 371    }
 372
 373    protected override void register_event_proxies()
 374    {
 375       base.register_event_proxies();
 376       evt_PauseEvt_delegate = new Efl.EventCb(on_PauseEvt_NativeCallback);
 377       evt_ResumeEvt_delegate = new Efl.EventCb(on_ResumeEvt_NativeCallback);
 378       evt_StandbyEvt_delegate = new Efl.EventCb(on_StandbyEvt_NativeCallback);
 379       evt_TerminateEvt_delegate = new Efl.EventCb(on_TerminateEvt_NativeCallback);
 380       evt_SignalUsr1Evt_delegate = new Efl.EventCb(on_SignalUsr1Evt_NativeCallback);
 381       evt_SignalUsr2Evt_delegate = new Efl.EventCb(on_SignalUsr2Evt_NativeCallback);
 382       evt_SignalHupEvt_delegate = new Efl.EventCb(on_SignalHupEvt_NativeCallback);
 383    }
 384    /// <summary>Returns the app object that is representing this process
 385    /// Note: This function call only works in the main loop thread of the process.</summary>
 386    /// <returns>Application for this process</returns>
 387    public static Efl.App GetAppMain() {
 388        var _ret_var = Efl.AppNativeInherit.efl_app_main_get_ptr.Value.Delegate();
 389       Eina.Error.RaiseIfUnhandledException();
 390       return _ret_var;
 391  }
 392    /// <summary>Indicates the version of EFL with which this application was compiled against/for.
 393    /// This might differ from <see cref="Efl.App.GetEflVersion"/>.</summary>
 394    /// <returns>Efl build version</returns>
 395    virtual public Efl.Version GetBuildEflVersion() {
 396        var _ret_var = Efl.AppNativeInherit.efl_app_build_efl_version_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 397       Eina.Error.RaiseIfUnhandledException();
 398       var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Version>(_ret_var);
 399
 400       return __ret_tmp;
 401  }
 402    /// <summary>Indicates the currently running version of EFL.
 403    /// This might differ from <see cref="Efl.App.GetBuildEflVersion"/>.</summary>
 404    /// <returns>Efl version</returns>
 405    virtual public Efl.Version GetEflVersion() {
 406        var _ret_var = Efl.AppNativeInherit.efl_app_efl_version_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 407       Eina.Error.RaiseIfUnhandledException();
 408       var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Version>(_ret_var);
 409
 410       return __ret_tmp;
 411  }
 412    /// <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.
 413    /// &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.
 414    ///
 415    /// 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:
 416    ///
 417    /// &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.
 418    ///
 419    /// 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>
 420    /// <returns></returns>
 421    virtual public  System.String GetCommand() {
 422        var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 423       Eina.Error.RaiseIfUnhandledException();
 424       return _ret_var;
 425  }
 426    /// <summary>Use an array to fill this object
 427    /// Every element of a string is a argument.</summary>
 428    /// <param name="array">An array where every array field is an argument</param>
 429    /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 430    virtual public bool SetCommandArray( Eina.Array< System.String> array) {
 431        var _in_array = array.Handle;
 432 array.Own = false;
 433 array.OwnContent = false;
 434                   var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_array_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_array);
 435       Eina.Error.RaiseIfUnhandledException();
 436                   return _ret_var;
 437  }
 438    /// <summary>Use a string to fill this object
 439    /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 440    /// <param name="str">A command in form of a string</param>
 441    /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 442    virtual public bool SetCommandString(  System.String str) {
 443                          var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), str);
 444       Eina.Error.RaiseIfUnhandledException();
 445                   return _ret_var;
 446  }
 447    /// <summary>Get the accessor which enables access to each argument that got passed to this object.</summary>
 448    /// <returns></returns>
 449    virtual public Eina.Accessor< System.String> CommandAccess() {
 450        var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_access_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 451       Eina.Error.RaiseIfUnhandledException();
 452       return new Eina.Accessor< System.String>(_ret_var, false, false);
 453  }
 454    /// <summary>Returns the app object that is representing this process
 455 /// Note: This function call only works in the main loop thread of the process.</summary>
 456 /// <value>Application for this process</value>
 457    public static Efl.App AppMain {
 458       get { return GetAppMain(); }
 459    }
 460    /// <summary>Indicates the version of EFL with which this application was compiled against/for.
 461 /// This might differ from <see cref="Efl.App.GetEflVersion"/>.</summary>
 462 /// <value>Efl build version</value>
 463    public Efl.Version BuildEflVersion {
 464       get { return GetBuildEflVersion(); }
 465    }
 466    /// <summary>Indicates the currently running version of EFL.
 467 /// This might differ from <see cref="Efl.App.GetBuildEflVersion"/>.</summary>
 468 /// <value>Efl version</value>
 469    public Efl.Version EflVersion {
 470       get { return GetEflVersion(); }
 471    }
 472    /// <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.
 473 /// &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.
 474 ///
 475 /// 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:
 476 ///
 477 /// &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.
 478 ///
 479 /// 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>
 480 /// <value></value>
 481    public  System.String Command {
 482       get { return GetCommand(); }
 483    }
 484    /// <summary>Use an array to fill this object
 485 /// Every element of a string is a argument.</summary>
 486 /// <value>An array where every array field is an argument</value>
 487    public Eina.Array< System.String> CommandArray {
 488       set { SetCommandArray( value); }
 489    }
 490    /// <summary>Use a string to fill this object
 491 /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 492 /// <value>A command in form of a string</value>
 493    public  System.String CommandString {
 494       set { SetCommandString( value); }
 495    }
 496    private static new  IntPtr GetEflClassStatic()
 497    {
 498       return Efl.App.efl_app_class_get();
 499    }
 500 }
 501 public class AppNativeInherit : Efl.LoopNativeInherit{
 502    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Ecore);
 503    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 504    {
 505       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 506       if (efl_app_build_efl_version_get_static_delegate == null)
 507       efl_app_build_efl_version_get_static_delegate = new efl_app_build_efl_version_get_delegate(build_efl_version_get);
 508       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)});
 509       if (efl_app_efl_version_get_static_delegate == null)
 510       efl_app_efl_version_get_static_delegate = new efl_app_efl_version_get_delegate(efl_version_get);
 511       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)});
 512       if (efl_core_command_line_command_get_static_delegate == null)
 513       efl_core_command_line_command_get_static_delegate = new efl_core_command_line_command_get_delegate(command_get);
 514       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)});
 515       if (efl_core_command_line_command_array_set_static_delegate == null)
 516       efl_core_command_line_command_array_set_static_delegate = new efl_core_command_line_command_array_set_delegate(command_array_set);
 517       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)});
 518       if (efl_core_command_line_command_string_set_static_delegate == null)
 519       efl_core_command_line_command_string_set_static_delegate = new efl_core_command_line_command_string_set_delegate(command_string_set);
 520       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)});
 521       if (efl_core_command_line_command_access_static_delegate == null)
 522       efl_core_command_line_command_access_static_delegate = new efl_core_command_line_command_access_delegate(command_access);
 523       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)});
 524       descs.AddRange(base.GetEoOps(type));
 525       return descs;
 526    }
 527    public override IntPtr GetEflClass()
 528    {
 529       return Efl.App.efl_app_class_get();
 530    }
 531    public static new  IntPtr GetEflClassStatic()
 532    {
 533       return Efl.App.efl_app_class_get();
 534    }
 535
 536
 537    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.App, Efl.Eo.NonOwnTag>))] private delegate Efl.App efl_app_main_get_delegate();
 538
 539
 540    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.App, Efl.Eo.NonOwnTag>))] public delegate Efl.App efl_app_main_get_api_delegate();
 541     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");
 542     private static Efl.App app_main_get(System.IntPtr obj, System.IntPtr pd)
 543    {
 544       Eina.Log.Debug("function efl_app_main_get was called");
 545       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 546       if(wrapper != null) {
 547                   Efl.App _ret_var = default(Efl.App);
 548          try {
 549             _ret_var = App.GetAppMain();
 550          } catch (Exception e) {
 551             Eina.Log.Warning($"Callback error: {e.ToString()}");
 552             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 553          }
 554       return _ret_var;
 555       } else {
 556          return efl_app_main_get_ptr.Value.Delegate();
 557       }
 558    }
 559
 560
 561     private delegate  System.IntPtr efl_app_build_efl_version_get_delegate(System.IntPtr obj, System.IntPtr pd);
 562
 563
 564     public delegate  System.IntPtr efl_app_build_efl_version_get_api_delegate(System.IntPtr obj);
 565     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");
 566     private static  System.IntPtr build_efl_version_get(System.IntPtr obj, System.IntPtr pd)
 567    {
 568       Eina.Log.Debug("function efl_app_build_efl_version_get was called");
 569       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 570       if(wrapper != null) {
 571                   Efl.Version _ret_var = default(Efl.Version);
 572          try {
 573             _ret_var = ((App)wrapper).GetBuildEflVersion();
 574          } catch (Exception e) {
 575             Eina.Log.Warning($"Callback error: {e.ToString()}");
 576             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 577          }
 578       return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
 579       } else {
 580          return efl_app_build_efl_version_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 581       }
 582    }
 583    private static efl_app_build_efl_version_get_delegate efl_app_build_efl_version_get_static_delegate;
 584
 585
 586     private delegate  System.IntPtr efl_app_efl_version_get_delegate(System.IntPtr obj, System.IntPtr pd);
 587
 588
 589     public delegate  System.IntPtr efl_app_efl_version_get_api_delegate(System.IntPtr obj);
 590     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");
 591     private static  System.IntPtr efl_version_get(System.IntPtr obj, System.IntPtr pd)
 592    {
 593       Eina.Log.Debug("function efl_app_efl_version_get was called");
 594       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 595       if(wrapper != null) {
 596                   Efl.Version _ret_var = default(Efl.Version);
 597          try {
 598             _ret_var = ((App)wrapper).GetEflVersion();
 599          } catch (Exception e) {
 600             Eina.Log.Warning($"Callback error: {e.ToString()}");
 601             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 602          }
 603       return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
 604       } else {
 605          return efl_app_efl_version_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 606       }
 607    }
 608    private static efl_app_efl_version_get_delegate efl_app_efl_version_get_static_delegate;
 609
 610
 611     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_core_command_line_command_get_delegate(System.IntPtr obj, System.IntPtr pd);
 612
 613
 614     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_core_command_line_command_get_api_delegate(System.IntPtr obj);
 615     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");
 616     private static  System.String command_get(System.IntPtr obj, System.IntPtr pd)
 617    {
 618       Eina.Log.Debug("function efl_core_command_line_command_get was called");
 619       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 620       if(wrapper != null) {
 621                    System.String _ret_var = default( System.String);
 622          try {
 623             _ret_var = ((App)wrapper).GetCommand();
 624          } catch (Exception e) {
 625             Eina.Log.Warning($"Callback error: {e.ToString()}");
 626             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 627          }
 628       return _ret_var;
 629       } else {
 630          return efl_core_command_line_command_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 631       }
 632    }
 633    private static efl_core_command_line_command_get_delegate efl_core_command_line_command_get_static_delegate;
 634
 635
 636     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_core_command_line_command_array_set_delegate(System.IntPtr obj, System.IntPtr pd,    System.IntPtr array);
 637
 638
 639     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_core_command_line_command_array_set_api_delegate(System.IntPtr obj,    System.IntPtr array);
 640     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");
 641     private static bool command_array_set(System.IntPtr obj, System.IntPtr pd,   System.IntPtr array)
 642    {
 643       Eina.Log.Debug("function efl_core_command_line_command_array_set was called");
 644       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 645       if(wrapper != null) {
 646                var _in_array = new Eina.Array< System.String>(array, true, true);
 647                      bool _ret_var = default(bool);
 648          try {
 649             _ret_var = ((App)wrapper).SetCommandArray( _in_array);
 650          } catch (Exception e) {
 651             Eina.Log.Warning($"Callback error: {e.ToString()}");
 652             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 653          }
 654                   return _ret_var;
 655       } else {
 656          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);
 657       }
 658    }
 659    private static efl_core_command_line_command_array_set_delegate efl_core_command_line_command_array_set_static_delegate;
 660
 661
 662     [return: MarshalAs(UnmanagedType.U1)] 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);
 663
 664
 665     [return: MarshalAs(UnmanagedType.U1)] 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);
 666     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");
 667     private static bool command_string_set(System.IntPtr obj, System.IntPtr pd,   System.String str)
 668    {
 669       Eina.Log.Debug("function efl_core_command_line_command_string_set was called");
 670       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 671       if(wrapper != null) {
 672                                     bool _ret_var = default(bool);
 673          try {
 674             _ret_var = ((App)wrapper).SetCommandString( str);
 675          } catch (Exception e) {
 676             Eina.Log.Warning($"Callback error: {e.ToString()}");
 677             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 678          }
 679                   return _ret_var;
 680       } else {
 681          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);
 682       }
 683    }
 684    private static efl_core_command_line_command_string_set_delegate efl_core_command_line_command_string_set_static_delegate;
 685
 686
 687     private delegate  System.IntPtr efl_core_command_line_command_access_delegate(System.IntPtr obj, System.IntPtr pd);
 688
 689
 690     public delegate  System.IntPtr efl_core_command_line_command_access_api_delegate(System.IntPtr obj);
 691     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");
 692     private static  System.IntPtr command_access(System.IntPtr obj, System.IntPtr pd)
 693    {
 694       Eina.Log.Debug("function efl_core_command_line_command_access was called");
 695       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 696       if(wrapper != null) {
 697                   Eina.Accessor< System.String> _ret_var = default(Eina.Accessor< System.String>);
 698          try {
 699             _ret_var = ((App)wrapper).CommandAccess();
 700          } catch (Exception e) {
 701             Eina.Log.Warning($"Callback error: {e.ToString()}");
 702             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 703          }
 704       return _ret_var.Handle;
 705       } else {
 706          return efl_core_command_line_command_access_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 707       }
 708    }
 709    private static efl_core_command_line_command_access_delegate efl_core_command_line_command_access_static_delegate;
 710 }
 711 }