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