internals/src/EflSharp/EflSharp/efl_access_window.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 Access {
   8 /// <summary>Elementary accessible window interface</summary>
   9 [WindowNativeInherit]
  10 public interface Window :
  11    Efl.Eo.IWrapper, IDisposable
  12 {
  13    /// <summary>Called when new window has been created.</summary>
  14    event EventHandler WindowCreatedEvt;
  15    /// <summary>Called when window has been destroyed.</summary>
  16    event EventHandler WindowDestroyedEvt;
  17    /// <summary>Called when window has been activated. (focused)</summary>
  18    event EventHandler WindowActivatedEvt;
  19    /// <summary>Called when window has been deactivated (unfocused).</summary>
  20    event EventHandler WindowDeactivatedEvt;
  21    /// <summary>Called when window has been maximized</summary>
  22    event EventHandler WindowMaximizedEvt;
  23    /// <summary>Called when window has been minimized</summary>
  24    event EventHandler WindowMinimizedEvt;
  25    /// <summary>Called when window has been restored</summary>
  26    event EventHandler WindowRestoredEvt;
  27 }
  28 /// <summary>Elementary accessible window interface</summary>
  29 sealed public class WindowConcrete :
  30
  31 Window
  32
  33 {
  34    ///<summary>Pointer to the native class description.</summary>
  35    public System.IntPtr NativeClass {
  36       get {
  37          if (((object)this).GetType() == typeof (WindowConcrete))
  38             return Efl.Access.WindowNativeInherit.GetEflClassStatic();
  39          else
  40             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  41       }
  42    }
  43    private EventHandlerList eventHandlers = new EventHandlerList();
  44    private  System.IntPtr handle;
  45    ///<summary>Pointer to the native instance.</summary>
  46    public System.IntPtr NativeHandle {
  47       get { return handle; }
  48    }
  49    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  50       efl_access_window_interface_get();
  51    ///<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>
  52    public WindowConcrete(System.IntPtr raw)
  53    {
  54       handle = raw;
  55       register_event_proxies();
  56    }
  57    ///<summary>Destructor.</summary>
  58    ~WindowConcrete()
  59    {
  60       Dispose(false);
  61    }
  62    ///<summary>Releases the underlying native instance.</summary>
  63    void Dispose(bool disposing)
  64    {
  65       if (handle != System.IntPtr.Zero) {
  66          Efl.Eo.Globals.efl_unref(handle);
  67          handle = System.IntPtr.Zero;
  68       }
  69    }
  70    ///<summary>Releases the underlying native instance.</summary>
  71    public void Dispose()
  72    {
  73       Dispose(true);
  74       GC.SuppressFinalize(this);
  75    }
  76    ///<summary>Casts obj into an instance of this type.</summary>
  77    public static WindowConcrete static_cast(Efl.Object obj)
  78    {
  79       if (obj == null)
  80          throw new System.ArgumentNullException("obj");
  81       return new WindowConcrete(obj.NativeHandle);
  82    }
  83    ///<summary>Verifies if the given object is equal to this one.</summary>
  84    public override bool Equals(object obj)
  85    {
  86       var other = obj as Efl.Object;
  87       if (other == null)
  88          return false;
  89       return this.NativeHandle == other.NativeHandle;
  90    }
  91    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  92    public override int GetHashCode()
  93    {
  94       return this.NativeHandle.ToInt32();
  95    }
  96    ///<summary>Turns the native pointer into a string representation.</summary>
  97    public override String ToString()
  98    {
  99       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 100    }
 101    private readonly object eventLock = new object();
 102    private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();
 103    private bool add_cpp_event_handler(string lib, string key, Efl.EventCb evt_delegate) {
 104       int event_count = 0;
 105       if (!event_cb_count.TryGetValue(key, out event_count))
 106          event_cb_count[key] = event_count;
 107       if (event_count == 0) {
 108          IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 109          if (desc == IntPtr.Zero) {
 110             Eina.Log.Error($"Failed to get native event {key}");
 111             return false;
 112          }
 113           bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);
 114          if (!result) {
 115             Eina.Log.Error($"Failed to add event proxy for event {key}");
 116             return false;
 117          }
 118          Eina.Error.RaiseIfUnhandledException();
 119       }
 120       event_cb_count[key]++;
 121       return true;
 122    }
 123    private bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {
 124       int event_count = 0;
 125       if (!event_cb_count.TryGetValue(key, out event_count))
 126          event_cb_count[key] = event_count;
 127       if (event_count == 1) {
 128          IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 129          if (desc == IntPtr.Zero) {
 130             Eina.Log.Error($"Failed to get native event {key}");
 131             return false;
 132          }
 133          bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);
 134          if (!result) {
 135             Eina.Log.Error($"Failed to remove event proxy for event {key}");
 136             return false;
 137          }
 138          Eina.Error.RaiseIfUnhandledException();
 139       } else if (event_count == 0) {
 140          Eina.Log.Error($"Trying to remove proxy for event {key} when there is nothing registered.");
 141          return false;
 142       }
 143       event_cb_count[key]--;
 144       return true;
 145    }
 146 private static object WindowCreatedEvtKey = new object();
 147    /// <summary>Called when new window has been created.</summary>
 148    public event EventHandler WindowCreatedEvt
 149    {
 150       add {
 151          lock (eventLock) {
 152             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_CREATED";
 153             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowCreatedEvt_delegate)) {
 154                eventHandlers.AddHandler(WindowCreatedEvtKey , value);
 155             } else
 156                Eina.Log.Error($"Error adding proxy for event {key}");
 157          }
 158       }
 159       remove {
 160          lock (eventLock) {
 161             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_CREATED";
 162             if (remove_cpp_event_handler(key, this.evt_WindowCreatedEvt_delegate)) {
 163                eventHandlers.RemoveHandler(WindowCreatedEvtKey , value);
 164             } else
 165                Eina.Log.Error($"Error removing proxy for event {key}");
 166          }
 167       }
 168    }
 169    ///<summary>Method to raise event WindowCreatedEvt.</summary>
 170    public void On_WindowCreatedEvt(EventArgs e)
 171    {
 172       EventHandler evt;
 173       lock (eventLock) {
 174       evt = (EventHandler)eventHandlers[WindowCreatedEvtKey];
 175       }
 176       evt?.Invoke(this, e);
 177    }
 178    Efl.EventCb evt_WindowCreatedEvt_delegate;
 179    private void on_WindowCreatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 180    {
 181       EventArgs args = EventArgs.Empty;
 182       try {
 183          On_WindowCreatedEvt(args);
 184       } catch (Exception e) {
 185          Eina.Log.Error(e.ToString());
 186          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 187       }
 188    }
 189
 190 private static object WindowDestroyedEvtKey = new object();
 191    /// <summary>Called when window has been destroyed.</summary>
 192    public event EventHandler WindowDestroyedEvt
 193    {
 194       add {
 195          lock (eventLock) {
 196             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_DESTROYED";
 197             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowDestroyedEvt_delegate)) {
 198                eventHandlers.AddHandler(WindowDestroyedEvtKey , value);
 199             } else
 200                Eina.Log.Error($"Error adding proxy for event {key}");
 201          }
 202       }
 203       remove {
 204          lock (eventLock) {
 205             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_DESTROYED";
 206             if (remove_cpp_event_handler(key, this.evt_WindowDestroyedEvt_delegate)) {
 207                eventHandlers.RemoveHandler(WindowDestroyedEvtKey , value);
 208             } else
 209                Eina.Log.Error($"Error removing proxy for event {key}");
 210          }
 211       }
 212    }
 213    ///<summary>Method to raise event WindowDestroyedEvt.</summary>
 214    public void On_WindowDestroyedEvt(EventArgs e)
 215    {
 216       EventHandler evt;
 217       lock (eventLock) {
 218       evt = (EventHandler)eventHandlers[WindowDestroyedEvtKey];
 219       }
 220       evt?.Invoke(this, e);
 221    }
 222    Efl.EventCb evt_WindowDestroyedEvt_delegate;
 223    private void on_WindowDestroyedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 224    {
 225       EventArgs args = EventArgs.Empty;
 226       try {
 227          On_WindowDestroyedEvt(args);
 228       } catch (Exception e) {
 229          Eina.Log.Error(e.ToString());
 230          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 231       }
 232    }
 233
 234 private static object WindowActivatedEvtKey = new object();
 235    /// <summary>Called when window has been activated. (focused)</summary>
 236    public event EventHandler WindowActivatedEvt
 237    {
 238       add {
 239          lock (eventLock) {
 240             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_ACTIVATED";
 241             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowActivatedEvt_delegate)) {
 242                eventHandlers.AddHandler(WindowActivatedEvtKey , value);
 243             } else
 244                Eina.Log.Error($"Error adding proxy for event {key}");
 245          }
 246       }
 247       remove {
 248          lock (eventLock) {
 249             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_ACTIVATED";
 250             if (remove_cpp_event_handler(key, this.evt_WindowActivatedEvt_delegate)) {
 251                eventHandlers.RemoveHandler(WindowActivatedEvtKey , value);
 252             } else
 253                Eina.Log.Error($"Error removing proxy for event {key}");
 254          }
 255       }
 256    }
 257    ///<summary>Method to raise event WindowActivatedEvt.</summary>
 258    public void On_WindowActivatedEvt(EventArgs e)
 259    {
 260       EventHandler evt;
 261       lock (eventLock) {
 262       evt = (EventHandler)eventHandlers[WindowActivatedEvtKey];
 263       }
 264       evt?.Invoke(this, e);
 265    }
 266    Efl.EventCb evt_WindowActivatedEvt_delegate;
 267    private void on_WindowActivatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 268    {
 269       EventArgs args = EventArgs.Empty;
 270       try {
 271          On_WindowActivatedEvt(args);
 272       } catch (Exception e) {
 273          Eina.Log.Error(e.ToString());
 274          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 275       }
 276    }
 277
 278 private static object WindowDeactivatedEvtKey = new object();
 279    /// <summary>Called when window has been deactivated (unfocused).</summary>
 280    public event EventHandler WindowDeactivatedEvt
 281    {
 282       add {
 283          lock (eventLock) {
 284             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_DEACTIVATED";
 285             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowDeactivatedEvt_delegate)) {
 286                eventHandlers.AddHandler(WindowDeactivatedEvtKey , value);
 287             } else
 288                Eina.Log.Error($"Error adding proxy for event {key}");
 289          }
 290       }
 291       remove {
 292          lock (eventLock) {
 293             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_DEACTIVATED";
 294             if (remove_cpp_event_handler(key, this.evt_WindowDeactivatedEvt_delegate)) {
 295                eventHandlers.RemoveHandler(WindowDeactivatedEvtKey , value);
 296             } else
 297                Eina.Log.Error($"Error removing proxy for event {key}");
 298          }
 299       }
 300    }
 301    ///<summary>Method to raise event WindowDeactivatedEvt.</summary>
 302    public void On_WindowDeactivatedEvt(EventArgs e)
 303    {
 304       EventHandler evt;
 305       lock (eventLock) {
 306       evt = (EventHandler)eventHandlers[WindowDeactivatedEvtKey];
 307       }
 308       evt?.Invoke(this, e);
 309    }
 310    Efl.EventCb evt_WindowDeactivatedEvt_delegate;
 311    private void on_WindowDeactivatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 312    {
 313       EventArgs args = EventArgs.Empty;
 314       try {
 315          On_WindowDeactivatedEvt(args);
 316       } catch (Exception e) {
 317          Eina.Log.Error(e.ToString());
 318          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 319       }
 320    }
 321
 322 private static object WindowMaximizedEvtKey = new object();
 323    /// <summary>Called when window has been maximized</summary>
 324    public event EventHandler WindowMaximizedEvt
 325    {
 326       add {
 327          lock (eventLock) {
 328             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_MAXIMIZED";
 329             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowMaximizedEvt_delegate)) {
 330                eventHandlers.AddHandler(WindowMaximizedEvtKey , value);
 331             } else
 332                Eina.Log.Error($"Error adding proxy for event {key}");
 333          }
 334       }
 335       remove {
 336          lock (eventLock) {
 337             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_MAXIMIZED";
 338             if (remove_cpp_event_handler(key, this.evt_WindowMaximizedEvt_delegate)) {
 339                eventHandlers.RemoveHandler(WindowMaximizedEvtKey , value);
 340             } else
 341                Eina.Log.Error($"Error removing proxy for event {key}");
 342          }
 343       }
 344    }
 345    ///<summary>Method to raise event WindowMaximizedEvt.</summary>
 346    public void On_WindowMaximizedEvt(EventArgs e)
 347    {
 348       EventHandler evt;
 349       lock (eventLock) {
 350       evt = (EventHandler)eventHandlers[WindowMaximizedEvtKey];
 351       }
 352       evt?.Invoke(this, e);
 353    }
 354    Efl.EventCb evt_WindowMaximizedEvt_delegate;
 355    private void on_WindowMaximizedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 356    {
 357       EventArgs args = EventArgs.Empty;
 358       try {
 359          On_WindowMaximizedEvt(args);
 360       } catch (Exception e) {
 361          Eina.Log.Error(e.ToString());
 362          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 363       }
 364    }
 365
 366 private static object WindowMinimizedEvtKey = new object();
 367    /// <summary>Called when window has been minimized</summary>
 368    public event EventHandler WindowMinimizedEvt
 369    {
 370       add {
 371          lock (eventLock) {
 372             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_MINIMIZED";
 373             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowMinimizedEvt_delegate)) {
 374                eventHandlers.AddHandler(WindowMinimizedEvtKey , value);
 375             } else
 376                Eina.Log.Error($"Error adding proxy for event {key}");
 377          }
 378       }
 379       remove {
 380          lock (eventLock) {
 381             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_MINIMIZED";
 382             if (remove_cpp_event_handler(key, this.evt_WindowMinimizedEvt_delegate)) {
 383                eventHandlers.RemoveHandler(WindowMinimizedEvtKey , value);
 384             } else
 385                Eina.Log.Error($"Error removing proxy for event {key}");
 386          }
 387       }
 388    }
 389    ///<summary>Method to raise event WindowMinimizedEvt.</summary>
 390    public void On_WindowMinimizedEvt(EventArgs e)
 391    {
 392       EventHandler evt;
 393       lock (eventLock) {
 394       evt = (EventHandler)eventHandlers[WindowMinimizedEvtKey];
 395       }
 396       evt?.Invoke(this, e);
 397    }
 398    Efl.EventCb evt_WindowMinimizedEvt_delegate;
 399    private void on_WindowMinimizedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 400    {
 401       EventArgs args = EventArgs.Empty;
 402       try {
 403          On_WindowMinimizedEvt(args);
 404       } catch (Exception e) {
 405          Eina.Log.Error(e.ToString());
 406          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 407       }
 408    }
 409
 410 private static object WindowRestoredEvtKey = new object();
 411    /// <summary>Called when window has been restored</summary>
 412    public event EventHandler WindowRestoredEvt
 413    {
 414       add {
 415          lock (eventLock) {
 416             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_RESTORED";
 417             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_WindowRestoredEvt_delegate)) {
 418                eventHandlers.AddHandler(WindowRestoredEvtKey , value);
 419             } else
 420                Eina.Log.Error($"Error adding proxy for event {key}");
 421          }
 422       }
 423       remove {
 424          lock (eventLock) {
 425             string key = "_EFL_ACCESS_WINDOW_EVENT_WINDOW_RESTORED";
 426             if (remove_cpp_event_handler(key, this.evt_WindowRestoredEvt_delegate)) {
 427                eventHandlers.RemoveHandler(WindowRestoredEvtKey , value);
 428             } else
 429                Eina.Log.Error($"Error removing proxy for event {key}");
 430          }
 431       }
 432    }
 433    ///<summary>Method to raise event WindowRestoredEvt.</summary>
 434    public void On_WindowRestoredEvt(EventArgs e)
 435    {
 436       EventHandler evt;
 437       lock (eventLock) {
 438       evt = (EventHandler)eventHandlers[WindowRestoredEvtKey];
 439       }
 440       evt?.Invoke(this, e);
 441    }
 442    Efl.EventCb evt_WindowRestoredEvt_delegate;
 443    private void on_WindowRestoredEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 444    {
 445       EventArgs args = EventArgs.Empty;
 446       try {
 447          On_WindowRestoredEvt(args);
 448       } catch (Exception e) {
 449          Eina.Log.Error(e.ToString());
 450          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 451       }
 452    }
 453
 454     void register_event_proxies()
 455    {
 456       evt_WindowCreatedEvt_delegate = new Efl.EventCb(on_WindowCreatedEvt_NativeCallback);
 457       evt_WindowDestroyedEvt_delegate = new Efl.EventCb(on_WindowDestroyedEvt_NativeCallback);
 458       evt_WindowActivatedEvt_delegate = new Efl.EventCb(on_WindowActivatedEvt_NativeCallback);
 459       evt_WindowDeactivatedEvt_delegate = new Efl.EventCb(on_WindowDeactivatedEvt_NativeCallback);
 460       evt_WindowMaximizedEvt_delegate = new Efl.EventCb(on_WindowMaximizedEvt_NativeCallback);
 461       evt_WindowMinimizedEvt_delegate = new Efl.EventCb(on_WindowMinimizedEvt_NativeCallback);
 462       evt_WindowRestoredEvt_delegate = new Efl.EventCb(on_WindowRestoredEvt_NativeCallback);
 463    }
 464 }
 465 public class WindowNativeInherit  : Efl.Eo.NativeClass{
 466    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 467    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 468    {
 469       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 470       return descs;
 471    }
 472    public override IntPtr GetEflClass()
 473    {
 474       return Efl.Access.WindowConcrete.efl_access_window_interface_get();
 475    }
 476    public static  IntPtr GetEflClassStatic()
 477    {
 478       return Efl.Access.WindowConcrete.efl_access_window_interface_get();
 479    }
 480 }
 481 } }