Circle and efl cs files are updated based on the latest efl.
Push and Pop methods have been added to Efl.Ui.ActiveView.Container.
Efl.Ui.RadioBox has been introduced.
Efl.Ui.Radio's interface has been changed.
e.g. RangeMinMax is modified to RangeLimits
{
double Minimum, Maximum;
- GetRangeMinMax(out Minimum, out Maximum);
+ GetRangeLimits(out Minimum, out Maximum);
if (Maximum == Minimum)
{
return 0.0;
_handle = Interop.Eext.eext_circle_surface_layout_add(layout.NativeHandle);
}
- public CircleUIManager(Efl.Ui.Stack naviframe)
+ public CircleUIManager(Efl.Ui.ActiveView.Container container)
{
- _handle = Interop.Eext.eext_circle_surface_naviframe_add(naviframe.NativeHandle);
+ _handle = Interop.Eext.eext_circle_surface_naviframe_add(container.NativeHandle);
}
public CircleUIManager()
}
+ /// The event argument of Rotary Selector editing state.
+ /// </summary>
+ /// <since_tizen> 6 </since_tizen>
+ public class RotarySelectorEditingEventArgs : EventArgs
+ {
+ public bool editing { get; internal set; }
+ }
+
/// <summary>
/// The RotarySelector is a widget to display a selector and multiple items surrounding the selector.
/// An item can be selected by the Rotary event or user item click.
const string ItemClickedEventName = "item,clicked";
const string ItemDeletedEventName = "item,deleted";
const string ItemReorderedEventName = "item,reordered";
+ const string EditingEnterEventName = "editing,entered";
+ const string EditingLeaveEventName = "editing,exited";
Image _normalBgImage;
/// <since_tizen> 6 </since_tizen>
public event EventHandler<RotarySelectorItemReorderedEventArgs> Reordered;
+ /// <summary>
+ /// Editing will be triggered when entering and leaving the editing state.
+ /// </summary>
+ /// <since_tizen> 6 </since_tizen>
+ public event EventHandler<RotarySelectorEditingEventArgs> EditingStateChanged;
+
private Interop.Evas.SmartCallback smartClicked;
private Interop.Evas.SmartCallback smartSelected;
private Interop.Evas.SmartCallback smartDeleted;
private Interop.Evas.SmartCallback smartReordered;
+ private Interop.Evas.SmartCallback smartEditingEnter;
+ private Interop.Evas.SmartCallback smartEditingLeave;
/// <summary>
/// Creates and initializes a new instance of the RotarySelector class.
UpdateListOrder(reorderedItem, idx);
});
+ smartEditingEnter = new Interop.Evas.SmartCallback((d, o, e) =>
+ {
+ EditingStateChanged?.Invoke(this, new RotarySelectorEditingEventArgs { editing = true});
+ });
+
+ smartEditingLeave = new Interop.Evas.SmartCallback((d, o, e) =>
+ {
+ EditingStateChanged?.Invoke(this, new RotarySelectorEditingEventArgs { editing = false });
+ });
+
Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemClickedEventName, smartClicked, IntPtr.Zero);
Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemSelectedEventName, smartSelected, IntPtr.Zero);
Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemDeletedEventName, smartDeleted, IntPtr.Zero);
Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, ItemReorderedEventName, smartReordered, IntPtr.Zero);
+ Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, EditingEnterEventName, smartEditingEnter, IntPtr.Zero);
+ Interop.Evas.evas_object_smart_callback_add(this.NativeHandle, EditingLeaveEventName, smartEditingLeave, IntPtr.Zero);
}
private void UpdateListOrder(RotarySelectorItem reorderedItem, int currentIdx)
Image _disabledBgImage;
Image _selectedBgImage;
Image _selectorIconImage;
+ bool _isRemovable;
/// <summary>
/// Sets or gets the color of the main text.
SetPart(BgPartName, ItemState.Normal, SelectedBgColor);
SetPart(SelectorIconPartName, ItemState.Normal, _selectorIconImage);
+
+ SetRemovable(_isRemovable);
}
get
{
}
}
+ void SetRemovable(bool isRemovable)
+ {
+ if (NativeHandle != null)
+ Interop.Eext.eext_rotary_selector_item_delete_enabled_set(NativeHandle, isRemovable);
+ }
+
/// <summary>
/// Sets or gets the main text.
/// </summary>
/// <since_tizen> 6 </since_tizen>
public bool IsRemovable
{
- get { return Interop.Eext.eext_rotary_selector_item_delete_enabled_get(NativeHandle); }
+ get { return _isRemovable; }
set
{
- Interop.Eext.eext_rotary_selector_item_delete_enabled_set(NativeHandle, value);
+ _isRemovable = value;
+ SetRemovable(value);
}
}
/// <summary>Register handlers to ownership events, in order to control the object lifetime. For internal use only.</summary>
private void AddOwnershipEventHandlers()
{
- AddNativeEventHandler("eo", "_EFL_EVENT_INVALIDATE", ownershipUniqueDelegate, ownershipUniqueDelegate);
- AddNativeEventHandler("eo", "_EFL_EVENT_OWNERSHIP_UNIQUE", ownershipUniqueDelegate, ownershipUniqueDelegate);
- AddNativeEventHandler("eo", "_EFL_EVENT_OWNERSHIP_SHARED", ownershipSharedDelegate, ownershipSharedDelegate);
+ AddNativeEventHandler(efl.Libs.Eo, "_EFL_EVENT_INVALIDATE", ownershipUniqueDelegate, ownershipUniqueDelegate);
+ AddNativeEventHandler(efl.Libs.Eo, "_EFL_EVENT_OWNERSHIP_UNIQUE", ownershipUniqueDelegate, ownershipUniqueDelegate);
+ AddNativeEventHandler(efl.Libs.Eo, "_EFL_EVENT_OWNERSHIP_SHARED", ownershipSharedDelegate, ownershipSharedDelegate);
Eina.Error.RaiseIfUnhandledException();
}
}
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActionName(id);
+ _ret_var = ((IAction)ws.Target).GetActionName(id);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActionLocalizedName(id);
+ _ret_var = ((IAction)ws.Target).GetActionLocalizedName(id);
}
catch (Exception e)
{
Eina.List<Efl.Access.ActionData> _ret_var = default(Eina.List<Efl.Access.ActionData>);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActions();
+ _ret_var = ((IAction)ws.Target).GetActions();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IActionConcrete)ws.Target).ActionDo(id);
+ _ret_var = ((IAction)ws.Target).ActionDo(id);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActionKeybinding(id);
+ _ret_var = ((IAction)ws.Target).GetActionKeybinding(id);
}
catch (Exception e)
{
};
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnVisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnPositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnStackingChangedEvt(EventArgs e)
{
var key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
int _ret_var = default(int);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetZOrder();
+ _ret_var = ((IComponent)ws.Target).GetZOrder();
}
catch (Exception e)
{
Eina.Rect _ret_var = default(Eina.Rect);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetExtents(screen_coords);
+ _ret_var = ((IComponent)ws.Target).GetExtents(screen_coords);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).SetExtents(screen_coords, _in_rect);
+ _ret_var = ((IComponent)ws.Target).SetExtents(screen_coords, _in_rect);
}
catch (Exception e)
{
x = default(int); y = default(int);
try
{
- ((IComponentConcrete)ws.Target).GetScreenPosition(out x, out y);
+ ((IComponent)ws.Target).GetScreenPosition(out x, out y);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).SetScreenPosition(x, y);
+ _ret_var = ((IComponent)ws.Target).SetScreenPosition(x, y);
}
catch (Exception e)
{
x = default(int); y = default(int);
try
{
- ((IComponentConcrete)ws.Target).GetSocketOffset(out x, out y);
+ ((IComponent)ws.Target).GetSocketOffset(out x, out y);
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetSocketOffset(x, y);
+ ((IComponent)ws.Target).SetSocketOffset(x, y);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).Contains(screen_coords, x, y);
+ _ret_var = ((IComponent)ws.Target).Contains(screen_coords, x, y);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GrabFocus();
+ _ret_var = ((IComponent)ws.Target).GrabFocus();
}
catch (Exception e)
{
Efl.Object _ret_var = default(Efl.Object);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetAccessibleAtPoint(screen_coords, x, y);
+ _ret_var = ((IComponent)ws.Target).GetAccessibleAtPoint(screen_coords, x, y);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GrabHighlight();
+ _ret_var = ((IComponent)ws.Target).GrabHighlight();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).ClearHighlight();
+ _ret_var = ((IComponent)ws.Target).ClearHighlight();
}
catch (Exception e)
{
Eina.Position2D _ret_var = default(Eina.Position2D);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetPosition();
+ _ret_var = ((IComponent)ws.Target).GetPosition();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetPosition(_in_pos);
+ ((IComponent)ws.Target).SetPosition(_in_pos);
}
catch (Exception e)
{
Eina.Size2D _ret_var = default(Eina.Size2D);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetSize();
+ _ret_var = ((IComponent)ws.Target).GetSize();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetSize(_in_size);
+ ((IComponent)ws.Target).SetSize(_in_size);
}
catch (Exception e)
{
Eina.Rect _ret_var = default(Eina.Rect);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetGeometry();
+ _ret_var = ((IComponent)ws.Target).GetGeometry();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetGeometry(_in_rect);
+ ((IComponent)ws.Target).SetGeometry(_in_rect);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetVisible();
+ _ret_var = ((IComponent)ws.Target).GetVisible();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetVisible(v);
+ ((IComponent)ws.Target).SetVisible(v);
}
catch (Exception e)
{
double _ret_var = default(double);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetScale();
+ _ret_var = ((IComponent)ws.Target).GetScale();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetScale(scale);
+ ((IComponent)ws.Target).SetScale(scale);
}
catch (Exception e)
{
short _ret_var = default(short);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetLayer();
+ _ret_var = ((IComponent)ws.Target).GetLayer();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).SetLayer(l);
+ ((IComponent)ws.Target).SetLayer(l);
}
catch (Exception e)
{
Efl.Gfx.IStack _ret_var = default(Efl.Gfx.IStack);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetBelow();
+ _ret_var = ((IComponent)ws.Target).GetBelow();
}
catch (Exception e)
{
Efl.Gfx.IStack _ret_var = default(Efl.Gfx.IStack);
try
{
- _ret_var = ((IComponentConcrete)ws.Target).GetAbove();
+ _ret_var = ((IComponent)ws.Target).GetAbove();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).StackBelow(below);
+ ((IComponent)ws.Target).StackBelow(below);
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).RaiseToTop();
+ ((IComponent)ws.Target).RaiseToTop();
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).StackAbove(above);
+ ((IComponent)ws.Target).StackAbove(above);
}
catch (Exception e)
{
try
{
- ((IComponentConcrete)ws.Target).LowerToBottom();
+ ((IComponent)ws.Target).LowerToBottom();
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetLocalizedRoleName();
+ _ret_var = ((IObject)ws.Target).GetLocalizedRoleName();
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetI18nName();
+ _ret_var = ((IObject)ws.Target).GetI18nName();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetI18nName(i18n_name);
+ ((IObject)ws.Target).SetI18nName(i18n_name);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetNameCb(name_cb, data);
+ ((IObject)ws.Target).SetNameCb(name_cb, data);
}
catch (Exception e)
{
Efl.Access.RelationSet _ret_var = default(Efl.Access.RelationSet);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetRelationSet();
+ _ret_var = ((IObject)ws.Target).GetRelationSet();
}
catch (Exception e)
{
Efl.Access.Role _ret_var = default(Efl.Access.Role);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetRole();
+ _ret_var = ((IObject)ws.Target).GetRole();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetRole(role);
+ ((IObject)ws.Target).SetRole(role);
}
catch (Exception e)
{
Efl.Access.IObject _ret_var = default(Efl.Access.IObject);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetAccessParent();
+ _ret_var = ((IObject)ws.Target).GetAccessParent();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetAccessParent(parent);
+ ((IObject)ws.Target).SetAccessParent(parent);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetDescriptionCb(description_cb, data);
+ ((IObject)ws.Target).SetDescriptionCb(description_cb, data);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetGestureCb(gesture_cb, data);
+ ((IObject)ws.Target).SetGestureCb(gesture_cb, data);
}
catch (Exception e)
{
Eina.List<Efl.Access.IObject> _ret_var = default(Eina.List<Efl.Access.IObject>);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetAccessChildren();
+ _ret_var = ((IObject)ws.Target).GetAccessChildren();
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetRoleName();
+ _ret_var = ((IObject)ws.Target).GetRoleName();
}
catch (Exception e)
{
Eina.List<Efl.Access.Attribute> _ret_var = default(Eina.List<Efl.Access.Attribute>);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetAttributes();
+ _ret_var = ((IObject)ws.Target).GetAttributes();
}
catch (Exception e)
{
Efl.Access.ReadingInfoTypeMask _ret_var = default(Efl.Access.ReadingInfoTypeMask);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetReadingInfoType();
+ _ret_var = ((IObject)ws.Target).GetReadingInfoType();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetReadingInfoType(reading_info);
+ ((IObject)ws.Target).SetReadingInfoType(reading_info);
}
catch (Exception e)
{
int _ret_var = default(int);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetIndexInParent();
+ _ret_var = ((IObject)ws.Target).GetIndexInParent();
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetDescription();
+ _ret_var = ((IObject)ws.Target).GetDescription();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetDescription(description);
+ ((IObject)ws.Target).SetDescription(description);
}
catch (Exception e)
{
Efl.Access.StateSet _ret_var = default(Efl.Access.StateSet);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetStateSet();
+ _ret_var = ((IObject)ws.Target).GetStateSet();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetCanHighlight();
+ _ret_var = ((IObject)ws.Target).GetCanHighlight();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetCanHighlight(can_highlight);
+ ((IObject)ws.Target).SetCanHighlight(can_highlight);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetTranslationDomain();
+ _ret_var = ((IObject)ws.Target).GetTranslationDomain();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetTranslationDomain(domain);
+ ((IObject)ws.Target).SetTranslationDomain(domain);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GestureDo(_in_gesture_info);
+ _ret_var = ((IObject)ws.Target).GestureDo(_in_gesture_info);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).AppendAttribute(key, value);
+ ((IObject)ws.Target).AppendAttribute(key, value);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).DelAttribute(key);
+ ((IObject)ws.Target).DelAttribute(key);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).ClearAttributes();
+ ((IObject)ws.Target).ClearAttributes();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).AppendRelationship(type, relation_object);
+ _ret_var = ((IObject)ws.Target).AppendRelationship(type, relation_object);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).RelationshipRemove(type, relation_object);
+ ((IObject)ws.Target).RelationshipRemove(type, relation_object);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).ClearRelationships();
+ ((IObject)ws.Target).ClearRelationships();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).StateNotify(state_types_mask, recursive);
+ ((IObject)ws.Target).StateNotify(state_types_mask, recursive);
}
catch (Exception e)
{
Efl.Access.ActionData _ret_var = default(Efl.Access.ActionData);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetElmActions();
+ _ret_var = ((IAction)ws.Target).GetElmActions();
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActionName(id);
+ _ret_var = ((IAction)ws.Target).GetActionName(id);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActionLocalizedName(id);
+ _ret_var = ((IAction)ws.Target).GetActionLocalizedName(id);
}
catch (Exception e)
{
Eina.List<Efl.Access.ActionData> _ret_var = default(Eina.List<Efl.Access.ActionData>);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActions();
+ _ret_var = ((IAction)ws.Target).GetActions();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IActionConcrete)ws.Target).ActionDo(id);
+ _ret_var = ((IAction)ws.Target).ActionDo(id);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IActionConcrete)ws.Target).GetActionKeybinding(id);
+ _ret_var = ((IAction)ws.Target).GetActionKeybinding(id);
}
catch (Exception e)
{
};
string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnClosedEvt(EventArgs e)
{
var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
{
var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_READER_EVENT_EOS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_READER_EVENT_EOS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnEosEvt(EventArgs e)
{
var key = "_EFL_IO_READER_EVENT_EOS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
{
var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_cached_item_interface_get();
/// <summary>Initializes a new instance of the <see cref="IItem"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
try
{
- ((IInternalConcrete)ws.Target).SetFilterChanged(val);
+ ((IInternal)ws.Target).SetFilterChanged(val);
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).SetFilterInvalid(val);
+ ((IInternal)ws.Target).SetFilterInvalid(val);
}
catch (Exception e)
{
System.IntPtr _ret_var = default(System.IntPtr);
try
{
- _ret_var = ((IInternalConcrete)ws.Target).GetFilterOutputBuffer();
+ _ret_var = ((IInternal)ws.Target).GetFilterOutputBuffer();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInternalConcrete)ws.Target).FilterInputAlpha();
+ _ret_var = ((IInternal)ws.Target).FilterInputAlpha();
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).FilterStatePrepare(out _out_state, data);
+ ((IInternal)ws.Target).FilterStatePrepare(out _out_state, data);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInternalConcrete)ws.Target).FilterInputRender(filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
+ _ret_var = ((IInternal)ws.Target).FilterInputRender(filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).FilterDirty();
+ ((IInternal)ws.Target).FilterDirty();
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).GetFilterProgram(out _out_code, out _out_name);
+ ((IInternal)ws.Target).GetFilterProgram(out _out_code, out _out_name);
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).SetFilterProgram(code, name);
+ ((IInternal)ws.Target).SetFilterProgram(code, name);
}
catch (Exception e)
{
next_val = default(double); pos = default(double);
try
{
- ((IInternalConcrete)ws.Target).GetFilterState(out _out_cur_state, out cur_val, out _out_next_state, out next_val, out pos);
+ ((IInternal)ws.Target).GetFilterState(out _out_cur_state, out cur_val, out _out_next_state, out next_val, out pos);
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).SetFilterState(cur_state, cur_val, next_state, next_val, pos);
+ ((IInternal)ws.Target).SetFilterState(cur_state, cur_val, next_state, next_val, pos);
}
catch (Exception e)
{
l = default(int); r = default(int); t = default(int); b = default(int);
try
{
- ((IInternalConcrete)ws.Target).GetFilterPadding(out l, out r, out t, out b);
+ ((IInternal)ws.Target).GetFilterPadding(out l, out r, out t, out b);
}
catch (Exception e)
{
Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
try
{
- _ret_var = ((IInternalConcrete)ws.Target).GetFilterSource(name);
+ _ret_var = ((IInternal)ws.Target).GetFilterSource(name);
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).SetFilterSource(name, source);
+ ((IInternal)ws.Target).SetFilterSource(name, source);
}
catch (Exception e)
{
execute = default(bool);
try
{
- ((IInternalConcrete)ws.Target).GetFilterData(name, out _out_value, out execute);
+ ((IInternal)ws.Target).GetFilterData(name, out _out_value, out execute);
}
catch (Exception e)
{
try
{
- ((IInternalConcrete)ws.Target).SetFilterData(name, value, execute);
+ ((IInternal)ws.Target).SetFilterData(name, value, execute);
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Evas\r)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
efl_canvas_gesture_triple_tap_class_get();
/// <summary>Initializes a new instance of the <see cref="GestureTripleTap"/> class.</summary>
/// <param name="parent">Parent instance.</param>
/// <summary>Get the internal clipper.
/// (Since EFL 1.22)</summary>
/// <returns>A clipper rectangle.</returns>
- virtual public Efl.Canvas.Object GetGroupClipper() {
+ virtual protected Efl.Canvas.Object GetGroupClipper() {
var _ret_var = Efl.Canvas.Group.NativeMethods.efl_canvas_group_clipper_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// This is the object clipping all the child objects. Do not delete or otherwise modify this clipper!
/// (Since EFL 1.22)</summary>
/// <value>A clipper rectangle.</value>
- public Efl.Canvas.Object GroupClipper {
+ protected Efl.Canvas.Object GroupClipper {
get { return GetGroupClipper(); }
}
private static IntPtr GetEflClassStatic()
};
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnLoadDoneEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
{
var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnImagePreloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnImageResizeEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnImageUnloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnVisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnPositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnSizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
--- /dev/null
+#pragma warning disable CS1591
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.ComponentModel;
+namespace Efl {
+
+namespace Canvas {
+
+/// <summary>Common class for part proxy objects for <see cref="Efl.Canvas.Layout"/>.
+/// As an <see cref="Efl.IPart"/> implementation class, all objects of this class are meant to be used for one and only one function call. In pseudo-code, the use of object of this type looks like the following: rect = layout.part("somepart").geometry_get();</summary>
+[Efl.Canvas.LayoutPartInvalid.NativeMethods]
+public class LayoutPartInvalid : Efl.Canvas.LayoutPart, Efl.IContainer, Efl.IContent, Efl.IPack, Efl.IPackLinear, Efl.IPackTable, Efl.IText, Efl.ITextCursor, Efl.ITextMarkup, Efl.ITextMarkupInteractive, Efl.Ui.ILayoutOrientable, Efl.Ui.ILayoutOrientableReadonly
+{
+ ///<summary>Pointer to the native class description.</summary>
+ public override System.IntPtr NativeClass
+ {
+ get
+ {
+ if (((object)this).GetType() == typeof(LayoutPartInvalid))
+ {
+ return GetEflClassStatic();
+ }
+ else
+ {
+ return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
+ }
+ }
+ }
+
+ [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
+ efl_canvas_layout_part_invalid_class_get();
+ /// <summary>Initializes a new instance of the <see cref="LayoutPartInvalid"/> class.</summary>
+ /// <param name="parent">Parent instance.</param>
+ public LayoutPartInvalid(Efl.Object parent= null
+ ) : base(efl_canvas_layout_part_invalid_class_get(), typeof(LayoutPartInvalid), parent)
+ {
+ FinishInstantiation();
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="LayoutPartInvalid"/> class.
+ /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
+ /// <param name="raw">The native pointer to be wrapped.</param>
+ protected LayoutPartInvalid(System.IntPtr raw) : base(raw)
+ {
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="LayoutPartInvalid"/> class.
+ /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
+ /// <param name="baseKlass">The pointer to the base native Eo class.</param>
+ /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
+ /// <param name="parent">The Efl.Object parent of this instance.</param>
+ protected LayoutPartInvalid(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
+ {
+ }
+
+ /// <summary>Sent after a new sub-object was added.
+ /// (Since EFL 1.22)</summary>
+ public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
+ {
+ add
+ {
+ lock (eventLock)
+ {
+ Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
+ {
+ var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
+ if (obj != null)
+ {
+ Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
+ args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
+ try
+ {
+ value?.Invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Error(e.ToString());
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+ }
+ };
+
+ string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ }
+ }
+
+ remove
+ {
+ lock (eventLock)
+ {
+ string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ }
+ }
+ }
+ ///<summary>Method to raise event ContentAddedEvt.</summary>
+ public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
+ {
+ var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ if (desc == IntPtr.Zero)
+ {
+ Eina.Log.Error($"Failed to get native event {key}");
+ return;
+ }
+
+ IntPtr info = e.arg.NativeHandle;
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ }
+ /// <summary>Sent after a sub-object was removed, before unref.
+ /// (Since EFL 1.22)</summary>
+ public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
+ {
+ add
+ {
+ lock (eventLock)
+ {
+ Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
+ {
+ var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
+ if (obj != null)
+ {
+ Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
+ args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
+ try
+ {
+ value?.Invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Error(e.ToString());
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+ }
+ };
+
+ string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ }
+ }
+
+ remove
+ {
+ lock (eventLock)
+ {
+ string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ }
+ }
+ }
+ ///<summary>Method to raise event ContentRemovedEvt.</summary>
+ public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
+ {
+ var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ if (desc == IntPtr.Zero)
+ {
+ Eina.Log.Error($"Failed to get native event {key}");
+ return;
+ }
+
+ IntPtr info = e.arg.NativeHandle;
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ }
+ /// <summary>Sent after the content is set or unset using the current content object.
+ /// (Since EFL 1.22)</summary>
+ public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
+ {
+ add
+ {
+ lock (eventLock)
+ {
+ Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
+ {
+ var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
+ if (obj != null)
+ {
+ Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
+ args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
+ try
+ {
+ value?.Invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Error(e.ToString());
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+ }
+ };
+
+ string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ }
+ }
+
+ remove
+ {
+ lock (eventLock)
+ {
+ string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ }
+ }
+ }
+ ///<summary>Method to raise event ContentChangedEvt.</summary>
+ public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
+ {
+ var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ if (desc == IntPtr.Zero)
+ {
+ Eina.Log.Error($"Failed to get native event {key}");
+ return;
+ }
+
+ IntPtr info = e.arg.NativeHandle;
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ }
+ /// <summary>Begin iterating over this object's contents.
+ /// (Since EFL 1.22)</summary>
+ /// <returns>Iterator on object's content.</returns>
+ virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
+ var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
+ }
+ /// <summary>Returns the number of contained sub-objects.
+ /// (Since EFL 1.22)</summary>
+ /// <returns>Number of sub-objects.</returns>
+ virtual public int ContentCount() {
+ var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Sub-object currently set as this object's single content.
+ /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
+ /// (Since EFL 1.22)</summary>
+ /// <returns>The sub-object.</returns>
+ virtual public Efl.Gfx.IEntity GetContent() {
+ var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Sub-object currently set as this object's single content.
+ /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
+ /// (Since EFL 1.22)</summary>
+ /// <param name="content">The sub-object.</param>
+ /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
+ virtual public bool SetContent(Efl.Gfx.IEntity content) {
+ var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
+ /// (Since EFL 1.22)</summary>
+ /// <returns>Unswallowed object</returns>
+ virtual public Efl.Gfx.IEntity UnsetContent() {
+ var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Removes all packed sub-objects and unreferences them.</summary>
+ /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
+ virtual public bool ClearPack() {
+ var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Removes all packed sub-objects without unreferencing them.
+ /// Use with caution.</summary>
+ /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
+ virtual public bool UnpackAll() {
+ var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
+ /// <param name="subobj">The sub-object to unpack.</param>
+ /// <returns><c>false</c> if <c>subobj</c> wasn't in the container or couldn't be removed.</returns>
+ virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
+ var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Adds a sub-object to this container.
+ /// Depending on the container this will either fill in the default spot, replacing any already existing element or append to the end of the container if there is no default part.
+ ///
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">The object to pack.</param>
+ /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
+ virtual public bool Pack(Efl.Gfx.IEntity subobj) {
+ var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Prepend an object at the beginning of this container.
+ /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
+ ///
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">Object to pack at the beginning.</param>
+ /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
+ virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Append object at the end of this container.
+ /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
+ ///
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">Object to pack at the end.</param>
+ /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
+ virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Prepend an object before an existing sub-object.
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">Object to pack before <c>existing</c>.</param>
+ /// <param name="existing">Existing reference sub-object.</param>
+ /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
+ virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, existing);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Append an object after an existing sub-object.
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">Object to pack after <c>existing</c>.</param>
+ /// <param name="existing">Existing reference sub-object.</param>
+ /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
+ virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, existing);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
+ /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
+ ///
+ /// If <c>index</c> is less than -<c>count</c>, it will trigger <see cref="Efl.IPackLinear.PackBegin"/>(<c>subobj</c>) whereas <c>index</c> greater than <c>count</c>-1 will trigger <see cref="Efl.IPackLinear.PackEnd"/>(<c>subobj</c>).
+ ///
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">Object to pack.</param>
+ /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
+ /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
+ virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, index);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Sub-object at a given <c>index</c> in this container.
+ /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
+ ///
+ /// If <c>index</c> is less than -<c>count</c>, it will return the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will return the last sub-object.</summary>
+ /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
+ /// <returns>The sub-object contained at the given <c>index</c>.</returns>
+ virtual public Efl.Gfx.IEntity GetPackContent(int index) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Get the index of a sub-object in this container.</summary>
+ /// <param name="subobj">An existing sub-object in this container.</param>
+ /// <returns>-1 in case <c>subobj</c> is not found, or the index of <c>subobj</c> in the range 0 to (<c>count</c>-1).</returns>
+ virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
+ /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
+ ///
+ /// If <c>index</c> is less than -<c>count</c>, it will remove the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will remove the last sub-object.</summary>
+ /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
+ /// <returns>The sub-object if it could be removed.</returns>
+ virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
+ var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Position and span of the <c>subobj</c> in this container, may be modified to move the <c>subobj</c></summary>
+ /// <param name="subobj">Child object</param>
+ /// <param name="col">Column number</param>
+ /// <param name="row">Row number</param>
+ /// <param name="colspan">Column span</param>
+ /// <param name="rowspan">Row span</param>
+ /// <returns>Returns false if item is not a child</returns>
+ virtual public bool GetTablePosition(Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan) {
+ var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, out col, out row, out colspan, out rowspan);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
+ /// <param name="cols">Number of columns</param>
+ /// <param name="rows">Number of rows</param>
+ virtual public void GetTableSize(out int cols, out int rows) {
+ Efl.IPackTableConcrete.NativeMethods.efl_pack_table_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out cols, out rows);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
+ /// <param name="cols">Number of columns</param>
+ /// <param name="rows">Number of rows</param>
+ virtual public void SetTableSize(int cols, int rows) {
+ Efl.IPackTableConcrete.NativeMethods.efl_pack_table_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cols, rows);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
+ /// <returns>Amount of columns.</returns>
+ virtual public int GetTableColumns() {
+ var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_columns_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
+ /// <param name="cols">Amount of columns.</param>
+ virtual public void SetTableColumns(int cols) {
+ Efl.IPackTableConcrete.NativeMethods.efl_pack_table_columns_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cols);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
+ /// <returns>Amount of rows.</returns>
+ virtual public int GetTableRows() {
+ var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_rows_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
+ /// <param name="rows">Amount of rows.</param>
+ virtual public void SetTableRows(int rows) {
+ Efl.IPackTableConcrete.NativeMethods.efl_pack_table_rows_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),rows);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Pack object at a given location in the table.
+ /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
+ /// <param name="subobj">A child object to pack in this table.</param>
+ /// <param name="col">Column number</param>
+ /// <param name="row">Row number</param>
+ /// <param name="colspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableColumns"/></param>
+ /// <param name="rowspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableRows"/></param>
+ /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
+ virtual public bool PackTable(Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan) {
+ var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, col, row, colspan, rowspan);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Returns all objects at a given position in this table.</summary>
+ /// <param name="col">Column number</param>
+ /// <param name="row">Row number</param>
+ /// <param name="below">If <c>true</c> get objects spanning over this cell.</param>
+ /// <returns>Iterator to table contents</returns>
+ virtual public Eina.Iterator<Efl.Gfx.IEntity> GetTableContents(int col, int row, bool below) {
+ var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_contents_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),col, row, below);
+ Eina.Error.RaiseIfUnhandledException();
+ return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
+ }
+ /// <summary>Returns a child at a given position, see <see cref="Efl.IPackTable.GetTableContents"/>.</summary>
+ /// <param name="col">Column number</param>
+ /// <param name="row">Row number</param>
+ /// <returns>Child object</returns>
+ virtual public Efl.Gfx.IEntity GetTableContent(int col, int row) {
+ var _ret_var = Efl.IPackTableConcrete.NativeMethods.efl_pack_table_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),col, row);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Retrieves the text string currently being displayed by the given text object.
+ /// Do not free() the return value.
+ ///
+ /// See also <see cref="Efl.IText.GetText"/>.
+ /// (Since EFL 1.22)</summary>
+ /// <returns>Text string to display on it.</returns>
+ virtual public System.String GetText() {
+ var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Sets the text string to be displayed by the given text object.
+ /// See also <see cref="Efl.IText.GetText"/>.
+ /// (Since EFL 1.22)</summary>
+ /// <param name="text">Text string to display on it.</param>
+ virtual public void SetText(System.String text) {
+ Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),text);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>The object's main cursor.</summary>
+ /// <param name="get_type">Cursor type</param>
+ /// <returns>Text cursor object</returns>
+ virtual public Efl.TextCursorCursor GetTextCursor(Efl.TextCursorGetType get_type) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),get_type);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Cursor position</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <returns>Cursor position</returns>
+ virtual public int GetCursorPosition(Efl.TextCursorCursor cur) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Cursor position</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <param name="position">Cursor position</param>
+ virtual public void SetCursorPosition(Efl.TextCursorCursor cur, int position) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, position);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>The content of the cursor (the character under the cursor)</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <returns>The unicode codepoint of the character</returns>
+ virtual public Eina.Unicode GetCursorContent(Efl.TextCursorCursor cur) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Returns the geometry of two cursors ("split cursor"), if logical cursor is between LTR/RTL text, also considering paragraph direction. Upper cursor is shown for the text of the same direction as paragraph, lower cursor - for opposite.
+ /// Split cursor geometry is valid only in '|' cursor mode. In this case <c>true</c> is returned and <c>cx2</c>, <c>cy2</c>, <c>cw2</c>, <c>ch2</c> are set.</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <param name="ctype">The type of the cursor.</param>
+ /// <param name="cx">The x of the cursor (or upper cursor)</param>
+ /// <param name="cy">The y of the cursor (or upper cursor)</param>
+ /// <param name="cw">The width of the cursor (or upper cursor)</param>
+ /// <param name="ch">The height of the cursor (or upper cursor)</param>
+ /// <param name="cx2">The x of the lower cursor</param>
+ /// <param name="cy2">The y of the lower cursor</param>
+ /// <param name="cw2">The width of the lower cursor</param>
+ /// <param name="ch2">The height of the lower cursor</param>
+ /// <returns><c>true</c> if split cursor, <c>false</c> otherwise.</returns>
+ virtual public bool GetCursorGeometry(Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Create new cursor</summary>
+ /// <returns>Cursor object</returns>
+ virtual public Efl.TextCursorCursor NewCursor() {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_new_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Free existing cursor</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorFree(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_free_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Check if two cursors are equal</summary>
+ /// <param name="cur1">Cursor 1 object</param>
+ /// <param name="cur2">Cursor 2 object</param>
+ /// <returns><c>true</c> if cursors are equal, <c>false</c> otherwise</returns>
+ virtual public bool CursorEqual(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_equal_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur1, cur2);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Compare two cursors</summary>
+ /// <param name="cur1">Cursor 1 object</param>
+ /// <param name="cur2">Cursor 2 object</param>
+ /// <returns>Difference between cursors</returns>
+ virtual public int CursorCompare(Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_compare_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur1, cur2);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Copy existing cursor</summary>
+ /// <param name="dst">Destination cursor</param>
+ /// <param name="src">Source cursor</param>
+ virtual public void CursorCopy(Efl.TextCursorCursor dst, Efl.TextCursorCursor src) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_copy_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dst, src);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the next character</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorCharNext(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the previous character</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorCharPrev(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the next grapheme cluster</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorClusterNext(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the previous grapheme cluster</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorClusterPrev(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the first character in this paragraph</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorParagraphCharFirst(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the last character in this paragraph</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorParagraphCharLast(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_char_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advance to current word start</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorWordStart(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advance to current word end</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorWordEnd(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_word_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advance to current line first character</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorLineCharFirst(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advance to current line last character</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorLineCharLast(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_char_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advance to current paragraph first character</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorParagraphFirst(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_first_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advance to current paragraph last character</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorParagraphLast(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_last_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the start of the next text node</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorParagraphNext(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_next_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Advances to the end of the previous text node</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorParagraphPrev(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_paragraph_prev_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Jump the cursor by the given number of lines</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <param name="by">Number of lines</param>
+ virtual public void CursorLineJumpBy(Efl.TextCursorCursor cur, int by) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_line_jump_by_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, by);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Set cursor coordinates</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <param name="x">X coord to set by.</param>
+ /// <param name="y">Y coord to set by.</param>
+ virtual public void SetCursorCoord(Efl.TextCursorCursor cur, int x, int y) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_coord_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, x, y);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Set cursor coordinates according to grapheme clusters. It does not allow to put a cursor to the middle of a grapheme cluster.</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <param name="x">X coord to set by.</param>
+ /// <param name="y">Y coord to set by.</param>
+ virtual public void SetCursorClusterCoord(Efl.TextCursorCursor cur, int x, int y) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_cluster_coord_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, x, y);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Adds text to the current cursor position and set the cursor to *after* the start of the text just added.</summary>
+ /// <param name="cur">Cursor object</param>
+ /// <param name="text">Text to append (UTF-8 format).</param>
+ /// <returns>Length of the appended text.</returns>
+ virtual public int CursorTextInsert(Efl.TextCursorCursor cur, System.String text) {
+ var _ret_var = Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_text_insert_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, text);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Deletes a single character from position pointed by given cursor.</summary>
+ /// <param name="cur">Cursor object</param>
+ virtual public void CursorCharDelete(Efl.TextCursorCursor cur) {
+ Efl.ITextCursorConcrete.NativeMethods.efl_text_cursor_char_delete_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Markup property</summary>
+ /// <returns>The markup-text representation set to this text.</returns>
+ virtual public System.String GetMarkup() {
+ var _ret_var = Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Markup property</summary>
+ /// <param name="markup">The markup-text representation set to this text.</param>
+ virtual public void SetMarkup(System.String markup) {
+ Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),markup);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Markup of a given range in the text</summary>
+ /// <param name="start">Start of the markup region</param>
+ /// <param name="end">End of markup region</param>
+ /// <returns>The markup-text representation set to this text of a given range</returns>
+ virtual public System.String GetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end) {
+ var _ret_var = Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start, end);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Markup of a given range in the text</summary>
+ /// <param name="start">Start of the markup region</param>
+ /// <param name="end">End of markup region</param>
+ /// <param name="markup">The markup-text representation set to this text of a given range</param>
+ virtual public void SetMarkupRange(Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup) {
+ Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_markup_range_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start, end, markup);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Inserts a markup text to the text object in a given cursor position</summary>
+ /// <param name="cur">Cursor position to insert markup</param>
+ /// <param name="markup">The markup text to insert</param>
+ virtual public void CursorMarkupInsert(Efl.TextCursorCursor cur, System.String markup) {
+ Efl.ITextMarkupInteractiveConcrete.NativeMethods.efl_text_markup_interactive_cursor_markup_insert_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cur, markup);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Control the direction of a given widget.
+ /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
+ ///
+ /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
+ /// <returns>Direction of the widget.</returns>
+ virtual public Efl.Ui.LayoutOrientation GetOrientation() {
+ var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Control the direction of a given widget.
+ /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
+ ///
+ /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
+ /// <param name="dir">Direction of the widget.</param>
+ virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
+ Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dir);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Sub-object currently set as this object's single content.
+ /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
+ /// (Since EFL 1.22)</summary>
+ /// <value>The sub-object.</value>
+ public Efl.Gfx.IEntity Content {
+ get { return GetContent(); }
+ set { SetContent(value); }
+ }
+ /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
+ /// <value>Amount of columns.</value>
+ public int TableColumns {
+ get { return GetTableColumns(); }
+ set { SetTableColumns(value); }
+ }
+ /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
+ /// <value>Amount of rows.</value>
+ public int TableRows {
+ get { return GetTableRows(); }
+ set { SetTableRows(value); }
+ }
+ /// <summary>Markup property</summary>
+ /// <value>The markup-text representation set to this text.</value>
+ public System.String Markup {
+ get { return GetMarkup(); }
+ set { SetMarkup(value); }
+ }
+ /// <summary>Control the direction of a given widget.
+ /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
+ ///
+ /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
+ /// <value>Direction of the widget.</value>
+ public Efl.Ui.LayoutOrientation Orientation {
+ get { return GetOrientation(); }
+ set { SetOrientation(value); }
+ }
+ private static IntPtr GetEflClassStatic()
+ {
+ return Efl.Canvas.LayoutPartInvalid.efl_canvas_layout_part_invalid_class_get();
+ }
+ /// <summary>Wrapper for native methods and virtual method delegates.
+ /// For internal use by generated code only.</summary>
+ public new class NativeMethods : Efl.Canvas.LayoutPart.NativeMethods
+ {
+ private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Edje);
+ /// <summary>Gets the list of Eo operations to override.</summary>
+ /// <returns>The list of Eo operations to be overload.</returns>
+ public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
+ {
+ var descs = new System.Collections.Generic.List<Efl_Op_Description>();
+ var methods = Efl.Eo.Globals.GetUserMethods(type);
+
+ if (efl_content_iterate_static_delegate == null)
+ {
+ efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_content_iterate_static_delegate) });
+ }
+
+ if (efl_content_count_static_delegate == null)
+ {
+ efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_count"), func = Marshal.GetFunctionPointerForDelegate(efl_content_count_static_delegate) });
+ }
+
+ if (efl_content_get_static_delegate == null)
+ {
+ efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
+ }
+
+ if (efl_content_set_static_delegate == null)
+ {
+ efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
+ }
+
+ if (efl_content_unset_static_delegate == null)
+ {
+ efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
+ }
+
+ if (efl_pack_clear_static_delegate == null)
+ {
+ efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_clear_static_delegate) });
+ }
+
+ if (efl_pack_unpack_all_static_delegate == null)
+ {
+ efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_all"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_all_static_delegate) });
+ }
+
+ if (efl_pack_unpack_static_delegate == null)
+ {
+ efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_static_delegate) });
+ }
+
+ if (efl_pack_static_delegate == null)
+ {
+ efl_pack_static_delegate = new efl_pack_delegate(pack);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
+ }
+
+ if (efl_pack_begin_static_delegate == null)
+ {
+ efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_begin"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_begin_static_delegate) });
+ }
+
+ if (efl_pack_end_static_delegate == null)
+ {
+ efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_end"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_end_static_delegate) });
+ }
+
+ if (efl_pack_before_static_delegate == null)
+ {
+ efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_before"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_before_static_delegate) });
+ }
+
+ if (efl_pack_after_static_delegate == null)
+ {
+ efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_after"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_after_static_delegate) });
+ }
+
+ if (efl_pack_at_static_delegate == null)
+ {
+ efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_at_static_delegate) });
+ }
+
+ if (efl_pack_content_get_static_delegate == null)
+ {
+ efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_content_get_static_delegate) });
+ }
+
+ if (efl_pack_index_get_static_delegate == null)
+ {
+ efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_index_get_static_delegate) });
+ }
+
+ if (efl_pack_unpack_at_static_delegate == null)
+ {
+ efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_at_static_delegate) });
+ }
+
+ if (efl_pack_table_position_get_static_delegate == null)
+ {
+ efl_pack_table_position_get_static_delegate = new efl_pack_table_position_get_delegate(table_position_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTablePosition") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_position_get_static_delegate) });
+ }
+
+ if (efl_pack_table_size_get_static_delegate == null)
+ {
+ efl_pack_table_size_get_static_delegate = new efl_pack_table_size_get_delegate(table_size_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTableSize") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_size_get_static_delegate) });
+ }
+
+ if (efl_pack_table_size_set_static_delegate == null)
+ {
+ efl_pack_table_size_set_static_delegate = new efl_pack_table_size_set_delegate(table_size_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetTableSize") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_size_set_static_delegate) });
+ }
+
+ if (efl_pack_table_columns_get_static_delegate == null)
+ {
+ efl_pack_table_columns_get_static_delegate = new efl_pack_table_columns_get_delegate(table_columns_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTableColumns") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_columns_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_columns_get_static_delegate) });
+ }
+
+ if (efl_pack_table_columns_set_static_delegate == null)
+ {
+ efl_pack_table_columns_set_static_delegate = new efl_pack_table_columns_set_delegate(table_columns_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetTableColumns") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_columns_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_columns_set_static_delegate) });
+ }
+
+ if (efl_pack_table_rows_get_static_delegate == null)
+ {
+ efl_pack_table_rows_get_static_delegate = new efl_pack_table_rows_get_delegate(table_rows_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTableRows") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_rows_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_rows_get_static_delegate) });
+ }
+
+ if (efl_pack_table_rows_set_static_delegate == null)
+ {
+ efl_pack_table_rows_set_static_delegate = new efl_pack_table_rows_set_delegate(table_rows_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetTableRows") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_rows_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_rows_set_static_delegate) });
+ }
+
+ if (efl_pack_table_static_delegate == null)
+ {
+ efl_pack_table_static_delegate = new efl_pack_table_delegate(pack_table);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "PackTable") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_static_delegate) });
+ }
+
+ if (efl_pack_table_contents_get_static_delegate == null)
+ {
+ efl_pack_table_contents_get_static_delegate = new efl_pack_table_contents_get_delegate(table_contents_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTableContents") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_contents_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_contents_get_static_delegate) });
+ }
+
+ if (efl_pack_table_content_get_static_delegate == null)
+ {
+ efl_pack_table_content_get_static_delegate = new efl_pack_table_content_get_delegate(table_content_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTableContent") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_table_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_table_content_get_static_delegate) });
+ }
+
+ if (efl_text_get_static_delegate == null)
+ {
+ efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_get_static_delegate) });
+ }
+
+ if (efl_text_set_static_delegate == null)
+ {
+ efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_set_static_delegate) });
+ }
+
+ if (efl_text_cursor_get_static_delegate == null)
+ {
+ efl_text_cursor_get_static_delegate = new efl_text_cursor_get_delegate(text_cursor_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetTextCursor") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_get_static_delegate) });
+ }
+
+ if (efl_text_cursor_position_get_static_delegate == null)
+ {
+ efl_text_cursor_position_get_static_delegate = new efl_text_cursor_position_get_delegate(cursor_position_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetCursorPosition") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_position_get_static_delegate) });
+ }
+
+ if (efl_text_cursor_position_set_static_delegate == null)
+ {
+ efl_text_cursor_position_set_static_delegate = new efl_text_cursor_position_set_delegate(cursor_position_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetCursorPosition") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_position_set_static_delegate) });
+ }
+
+ if (efl_text_cursor_content_get_static_delegate == null)
+ {
+ efl_text_cursor_content_get_static_delegate = new efl_text_cursor_content_get_delegate(cursor_content_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetCursorContent") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_content_get_static_delegate) });
+ }
+
+ if (efl_text_cursor_geometry_get_static_delegate == null)
+ {
+ efl_text_cursor_geometry_get_static_delegate = new efl_text_cursor_geometry_get_delegate(cursor_geometry_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetCursorGeometry") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_geometry_get_static_delegate) });
+ }
+
+ if (efl_text_cursor_new_static_delegate == null)
+ {
+ efl_text_cursor_new_static_delegate = new efl_text_cursor_new_delegate(cursor_new);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "NewCursor") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_new"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_new_static_delegate) });
+ }
+
+ if (efl_text_cursor_free_static_delegate == null)
+ {
+ efl_text_cursor_free_static_delegate = new efl_text_cursor_free_delegate(cursor_free);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorFree") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_free"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_free_static_delegate) });
+ }
+
+ if (efl_text_cursor_equal_static_delegate == null)
+ {
+ efl_text_cursor_equal_static_delegate = new efl_text_cursor_equal_delegate(cursor_equal);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorEqual") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_equal"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_equal_static_delegate) });
+ }
+
+ if (efl_text_cursor_compare_static_delegate == null)
+ {
+ efl_text_cursor_compare_static_delegate = new efl_text_cursor_compare_delegate(cursor_compare);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorCompare") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_compare"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_compare_static_delegate) });
+ }
+
+ if (efl_text_cursor_copy_static_delegate == null)
+ {
+ efl_text_cursor_copy_static_delegate = new efl_text_cursor_copy_delegate(cursor_copy);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorCopy") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_copy"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_copy_static_delegate) });
+ }
+
+ if (efl_text_cursor_char_next_static_delegate == null)
+ {
+ efl_text_cursor_char_next_static_delegate = new efl_text_cursor_char_next_delegate(cursor_char_next);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorCharNext") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_char_next"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_char_next_static_delegate) });
+ }
+
+ if (efl_text_cursor_char_prev_static_delegate == null)
+ {
+ efl_text_cursor_char_prev_static_delegate = new efl_text_cursor_char_prev_delegate(cursor_char_prev);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorCharPrev") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_char_prev"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_char_prev_static_delegate) });
+ }
+
+ if (efl_text_cursor_cluster_next_static_delegate == null)
+ {
+ efl_text_cursor_cluster_next_static_delegate = new efl_text_cursor_cluster_next_delegate(cursor_cluster_next);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorClusterNext") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_cluster_next"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_cluster_next_static_delegate) });
+ }
+
+ if (efl_text_cursor_cluster_prev_static_delegate == null)
+ {
+ efl_text_cursor_cluster_prev_static_delegate = new efl_text_cursor_cluster_prev_delegate(cursor_cluster_prev);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorClusterPrev") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_cluster_prev"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_cluster_prev_static_delegate) });
+ }
+
+ if (efl_text_cursor_paragraph_char_first_static_delegate == null)
+ {
+ efl_text_cursor_paragraph_char_first_static_delegate = new efl_text_cursor_paragraph_char_first_delegate(cursor_paragraph_char_first);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharFirst") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_char_first"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_char_first_static_delegate) });
+ }
+
+ if (efl_text_cursor_paragraph_char_last_static_delegate == null)
+ {
+ efl_text_cursor_paragraph_char_last_static_delegate = new efl_text_cursor_paragraph_char_last_delegate(cursor_paragraph_char_last);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorParagraphCharLast") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_char_last"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_char_last_static_delegate) });
+ }
+
+ if (efl_text_cursor_word_start_static_delegate == null)
+ {
+ efl_text_cursor_word_start_static_delegate = new efl_text_cursor_word_start_delegate(cursor_word_start);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorWordStart") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_word_start"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_word_start_static_delegate) });
+ }
+
+ if (efl_text_cursor_word_end_static_delegate == null)
+ {
+ efl_text_cursor_word_end_static_delegate = new efl_text_cursor_word_end_delegate(cursor_word_end);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorWordEnd") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_word_end"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_word_end_static_delegate) });
+ }
+
+ if (efl_text_cursor_line_char_first_static_delegate == null)
+ {
+ efl_text_cursor_line_char_first_static_delegate = new efl_text_cursor_line_char_first_delegate(cursor_line_char_first);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorLineCharFirst") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_line_char_first"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_line_char_first_static_delegate) });
+ }
+
+ if (efl_text_cursor_line_char_last_static_delegate == null)
+ {
+ efl_text_cursor_line_char_last_static_delegate = new efl_text_cursor_line_char_last_delegate(cursor_line_char_last);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorLineCharLast") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_line_char_last"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_line_char_last_static_delegate) });
+ }
+
+ if (efl_text_cursor_paragraph_first_static_delegate == null)
+ {
+ efl_text_cursor_paragraph_first_static_delegate = new efl_text_cursor_paragraph_first_delegate(cursor_paragraph_first);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorParagraphFirst") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_first"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_first_static_delegate) });
+ }
+
+ if (efl_text_cursor_paragraph_last_static_delegate == null)
+ {
+ efl_text_cursor_paragraph_last_static_delegate = new efl_text_cursor_paragraph_last_delegate(cursor_paragraph_last);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorParagraphLast") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_last"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_last_static_delegate) });
+ }
+
+ if (efl_text_cursor_paragraph_next_static_delegate == null)
+ {
+ efl_text_cursor_paragraph_next_static_delegate = new efl_text_cursor_paragraph_next_delegate(cursor_paragraph_next);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorParagraphNext") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_next"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_next_static_delegate) });
+ }
+
+ if (efl_text_cursor_paragraph_prev_static_delegate == null)
+ {
+ efl_text_cursor_paragraph_prev_static_delegate = new efl_text_cursor_paragraph_prev_delegate(cursor_paragraph_prev);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorParagraphPrev") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_paragraph_prev"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_paragraph_prev_static_delegate) });
+ }
+
+ if (efl_text_cursor_line_jump_by_static_delegate == null)
+ {
+ efl_text_cursor_line_jump_by_static_delegate = new efl_text_cursor_line_jump_by_delegate(cursor_line_jump_by);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorLineJumpBy") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_line_jump_by"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_line_jump_by_static_delegate) });
+ }
+
+ if (efl_text_cursor_coord_set_static_delegate == null)
+ {
+ efl_text_cursor_coord_set_static_delegate = new efl_text_cursor_coord_set_delegate(cursor_coord_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetCursorCoord") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_coord_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_coord_set_static_delegate) });
+ }
+
+ if (efl_text_cursor_cluster_coord_set_static_delegate == null)
+ {
+ efl_text_cursor_cluster_coord_set_static_delegate = new efl_text_cursor_cluster_coord_set_delegate(cursor_cluster_coord_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetCursorClusterCoord") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_cluster_coord_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_cluster_coord_set_static_delegate) });
+ }
+
+ if (efl_text_cursor_text_insert_static_delegate == null)
+ {
+ efl_text_cursor_text_insert_static_delegate = new efl_text_cursor_text_insert_delegate(cursor_text_insert);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorTextInsert") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_text_insert"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_text_insert_static_delegate) });
+ }
+
+ if (efl_text_cursor_char_delete_static_delegate == null)
+ {
+ efl_text_cursor_char_delete_static_delegate = new efl_text_cursor_char_delete_delegate(cursor_char_delete);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorCharDelete") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_cursor_char_delete"), func = Marshal.GetFunctionPointerForDelegate(efl_text_cursor_char_delete_static_delegate) });
+ }
+
+ if (efl_text_markup_get_static_delegate == null)
+ {
+ efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetMarkup") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_get_static_delegate) });
+ }
+
+ if (efl_text_markup_set_static_delegate == null)
+ {
+ efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetMarkup") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_set_static_delegate) });
+ }
+
+ if (efl_text_markup_interactive_markup_range_get_static_delegate == null)
+ {
+ efl_text_markup_interactive_markup_range_get_static_delegate = new efl_text_markup_interactive_markup_range_get_delegate(markup_range_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetMarkupRange") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_interactive_markup_range_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_interactive_markup_range_get_static_delegate) });
+ }
+
+ if (efl_text_markup_interactive_markup_range_set_static_delegate == null)
+ {
+ efl_text_markup_interactive_markup_range_set_static_delegate = new efl_text_markup_interactive_markup_range_set_delegate(markup_range_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetMarkupRange") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_interactive_markup_range_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_interactive_markup_range_set_static_delegate) });
+ }
+
+ if (efl_text_markup_interactive_cursor_markup_insert_static_delegate == null)
+ {
+ efl_text_markup_interactive_cursor_markup_insert_static_delegate = new efl_text_markup_interactive_cursor_markup_insert_delegate(cursor_markup_insert);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "CursorMarkupInsert") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_interactive_cursor_markup_insert"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_interactive_cursor_markup_insert_static_delegate) });
+ }
+
+ if (efl_ui_layout_orientation_get_static_delegate == null)
+ {
+ efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_get_static_delegate) });
+ }
+
+ if (efl_ui_layout_orientation_set_static_delegate == null)
+ {
+ efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_set_static_delegate) });
+ }
+
+ descs.AddRange(base.GetEoOps(type));
+ return descs;
+ }
+ /// <summary>Returns the Eo class for the native methods of this class.</summary>
+ /// <returns>The native class pointer.</returns>
+ public override IntPtr GetEflClass()
+ {
+ return Efl.Canvas.LayoutPartInvalid.efl_canvas_layout_part_invalid_class_get();
+ }
+
+ #pragma warning disable CA1707, CS1591, SA1300, SA1600
+
+
+ private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate> efl_content_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate>(Module, "efl_content_iterate");
+
+ private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_content_iterate was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).ContentIterate();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ _ret_var.Own = false; return _ret_var.Handle;
+
+ }
+ else
+ {
+ return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
+
+
+ private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate int efl_content_count_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_content_count_api_delegate> efl_content_count_ptr = new Efl.Eo.FunctionWrapper<efl_content_count_api_delegate>(Module, "efl_content_count");
+
+ private static int content_count(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_content_count was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).ContentCount();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_content_count_delegate efl_content_count_static_delegate;
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
+
+ private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_content_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetContent();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_content_get_delegate efl_content_get_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
+
+ public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
+
+ private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
+ {
+ Eina.Log.Debug("function efl_content_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).SetContent(content);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
+ }
+ }
+
+ private static efl_content_set_delegate efl_content_set_static_delegate;
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
+
+ private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_content_unset was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).UnsetContent();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_content_unset_delegate efl_content_unset_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate> efl_pack_clear_ptr = new Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate>(Module, "efl_pack_clear");
+
+ private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_pack_clear was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).ClearPack();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate> efl_pack_unpack_all_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate>(Module, "efl_pack_unpack_all");
+
+ private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_pack_unpack_all was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).UnpackAll();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate> efl_pack_unpack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate>(Module, "efl_pack_unpack");
+
+ private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
+ {
+ Eina.Log.Debug("function efl_pack_unpack was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).Unpack(subobj);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
+ }
+ }
+
+ private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
+
+ private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
+ {
+ Eina.Log.Debug("function efl_pack was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).Pack(subobj);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
+ }
+ }
+
+ private static efl_pack_delegate efl_pack_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate> efl_pack_begin_ptr = new Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate>(Module, "efl_pack_begin");
+
+ private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
+ {
+ Eina.Log.Debug("function efl_pack_begin was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackBegin(subobj);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
+ }
+ }
+
+ private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate> efl_pack_end_ptr = new Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate>(Module, "efl_pack_end");
+
+ private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
+ {
+ Eina.Log.Debug("function efl_pack_end was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackEnd(subobj);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
+ }
+ }
+
+ private static efl_pack_end_delegate efl_pack_end_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate> efl_pack_before_ptr = new Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate>(Module, "efl_pack_before");
+
+ private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
+ {
+ Eina.Log.Debug("function efl_pack_before was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackBefore(subobj, existing);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
+ }
+ }
+
+ private static efl_pack_before_delegate efl_pack_before_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate> efl_pack_after_ptr = new Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate>(Module, "efl_pack_after");
+
+ private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
+ {
+ Eina.Log.Debug("function efl_pack_after was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackAfter(subobj, existing);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
+ }
+ }
+
+ private static efl_pack_after_delegate efl_pack_after_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, int index);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, int index);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate> efl_pack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate>(Module, "efl_pack_at");
+
+ private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
+ {
+ Eina.Log.Debug("function efl_pack_at was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackAt(subobj, index);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
+ }
+ }
+
+ private static efl_pack_at_delegate efl_pack_at_static_delegate;
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd, int index);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj, int index);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate> efl_pack_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate>(Module, "efl_pack_content_get");
+
+ private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
+ {
+ Eina.Log.Debug("function efl_pack_content_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetPackContent(index);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
+ }
+ }
+
+ private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
+
+
+ private delegate int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+
+ public delegate int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate> efl_pack_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate>(Module, "efl_pack_index_get");
+
+ private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
+ {
+ Eina.Log.Debug("function efl_pack_index_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetPackIndex(subobj);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
+ }
+ }
+
+ private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd, int index);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj, int index);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate> efl_pack_unpack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate>(Module, "efl_pack_unpack_at");
+
+ private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
+ {
+ Eina.Log.Debug("function efl_pack_unpack_at was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackUnpackAt(index);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
+ }
+ }
+
+ private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_table_position_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_table_position_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_position_get_api_delegate> efl_pack_table_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_position_get_api_delegate>(Module, "efl_pack_table_position_get");
+
+ private static bool table_position_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan)
+ {
+ Eina.Log.Debug("function efl_pack_table_position_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ col = default(int); row = default(int); colspan = default(int); rowspan = default(int); bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetTablePosition(subobj, out col, out row, out colspan, out rowspan);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_table_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, out col, out row, out colspan, out rowspan);
+ }
+ }
+
+ private static efl_pack_table_position_get_delegate efl_pack_table_position_get_static_delegate;
+
+
+ private delegate void efl_pack_table_size_get_delegate(System.IntPtr obj, System.IntPtr pd, out int cols, out int rows);
+
+
+ public delegate void efl_pack_table_size_get_api_delegate(System.IntPtr obj, out int cols, out int rows);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_size_get_api_delegate> efl_pack_table_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_size_get_api_delegate>(Module, "efl_pack_table_size_get");
+
+ private static void table_size_get(System.IntPtr obj, System.IntPtr pd, out int cols, out int rows)
+ {
+ Eina.Log.Debug("function efl_pack_table_size_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ cols = default(int); rows = default(int);
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).GetTableSize(out cols, out rows);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_pack_table_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out cols, out rows);
+ }
+ }
+
+ private static efl_pack_table_size_get_delegate efl_pack_table_size_get_static_delegate;
+
+
+ private delegate void efl_pack_table_size_set_delegate(System.IntPtr obj, System.IntPtr pd, int cols, int rows);
+
+
+ public delegate void efl_pack_table_size_set_api_delegate(System.IntPtr obj, int cols, int rows);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_size_set_api_delegate> efl_pack_table_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_size_set_api_delegate>(Module, "efl_pack_table_size_set");
+
+ private static void table_size_set(System.IntPtr obj, System.IntPtr pd, int cols, int rows)
+ {
+ Eina.Log.Debug("function efl_pack_table_size_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetTableSize(cols, rows);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_pack_table_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols, rows);
+ }
+ }
+
+ private static efl_pack_table_size_set_delegate efl_pack_table_size_set_static_delegate;
+
+
+ private delegate int efl_pack_table_columns_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate int efl_pack_table_columns_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_columns_get_api_delegate> efl_pack_table_columns_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_columns_get_api_delegate>(Module, "efl_pack_table_columns_get");
+
+ private static int table_columns_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_pack_table_columns_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetTableColumns();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_table_columns_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_pack_table_columns_get_delegate efl_pack_table_columns_get_static_delegate;
+
+
+ private delegate void efl_pack_table_columns_set_delegate(System.IntPtr obj, System.IntPtr pd, int cols);
+
+
+ public delegate void efl_pack_table_columns_set_api_delegate(System.IntPtr obj, int cols);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_columns_set_api_delegate> efl_pack_table_columns_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_columns_set_api_delegate>(Module, "efl_pack_table_columns_set");
+
+ private static void table_columns_set(System.IntPtr obj, System.IntPtr pd, int cols)
+ {
+ Eina.Log.Debug("function efl_pack_table_columns_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetTableColumns(cols);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_pack_table_columns_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols);
+ }
+ }
+
+ private static efl_pack_table_columns_set_delegate efl_pack_table_columns_set_static_delegate;
+
+
+ private delegate int efl_pack_table_rows_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate int efl_pack_table_rows_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_rows_get_api_delegate> efl_pack_table_rows_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_rows_get_api_delegate>(Module, "efl_pack_table_rows_get");
+
+ private static int table_rows_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_pack_table_rows_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetTableRows();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_table_rows_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_pack_table_rows_get_delegate efl_pack_table_rows_get_static_delegate;
+
+
+ private delegate void efl_pack_table_rows_set_delegate(System.IntPtr obj, System.IntPtr pd, int rows);
+
+
+ public delegate void efl_pack_table_rows_set_api_delegate(System.IntPtr obj, int rows);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_rows_set_api_delegate> efl_pack_table_rows_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_rows_set_api_delegate>(Module, "efl_pack_table_rows_set");
+
+ private static void table_rows_set(System.IntPtr obj, System.IntPtr pd, int rows)
+ {
+ Eina.Log.Debug("function efl_pack_table_rows_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetTableRows(rows);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_pack_table_rows_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rows);
+ }
+ }
+
+ private static efl_pack_table_rows_set_delegate efl_pack_table_rows_set_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_pack_table_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_pack_table_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_api_delegate> efl_pack_table_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_api_delegate>(Module, "efl_pack_table");
+
+ private static bool pack_table(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan)
+ {
+ Eina.Log.Debug("function efl_pack_table was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).PackTable(subobj, col, row, colspan, rowspan);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_table_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, col, row, colspan, rowspan);
+ }
+ }
+
+ private static efl_pack_table_delegate efl_pack_table_static_delegate;
+
+
+ private delegate System.IntPtr efl_pack_table_contents_get_delegate(System.IntPtr obj, System.IntPtr pd, int col, int row, [MarshalAs(UnmanagedType.U1)] bool below);
+
+
+ public delegate System.IntPtr efl_pack_table_contents_get_api_delegate(System.IntPtr obj, int col, int row, [MarshalAs(UnmanagedType.U1)] bool below);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_contents_get_api_delegate> efl_pack_table_contents_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_contents_get_api_delegate>(Module, "efl_pack_table_contents_get");
+
+ private static System.IntPtr table_contents_get(System.IntPtr obj, System.IntPtr pd, int col, int row, bool below)
+ {
+ Eina.Log.Debug("function efl_pack_table_contents_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetTableContents(col, row, below);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ _ret_var.Own = false; return _ret_var.Handle;
+
+ }
+ else
+ {
+ return efl_pack_table_contents_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), col, row, below);
+ }
+ }
+
+ private static efl_pack_table_contents_get_delegate efl_pack_table_contents_get_static_delegate;
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Gfx.IEntity efl_pack_table_content_get_delegate(System.IntPtr obj, System.IntPtr pd, int col, int row);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Gfx.IEntity efl_pack_table_content_get_api_delegate(System.IntPtr obj, int col, int row);
+
+ public static Efl.Eo.FunctionWrapper<efl_pack_table_content_get_api_delegate> efl_pack_table_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_table_content_get_api_delegate>(Module, "efl_pack_table_content_get");
+
+ private static Efl.Gfx.IEntity table_content_get(System.IntPtr obj, System.IntPtr pd, int col, int row)
+ {
+ Eina.Log.Debug("function efl_pack_table_content_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetTableContent(col, row);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_pack_table_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), col, row);
+ }
+ }
+
+ private static efl_pack_table_content_get_delegate efl_pack_table_content_get_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
+ private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
+ public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_get_api_delegate> efl_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_get_api_delegate>(Module, "efl_text_get");
+
+ private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_text_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ System.String _ret_var = default(System.String);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetText();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_text_get_delegate efl_text_get_static_delegate;
+
+
+ private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
+
+
+ public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_set_api_delegate> efl_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_set_api_delegate>(Module, "efl_text_set");
+
+ private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
+ {
+ Eina.Log.Debug("function efl_text_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetText(text);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
+ }
+ }
+
+ private static efl_text_set_delegate efl_text_set_static_delegate;
+
+
+ private delegate Efl.TextCursorCursor efl_text_cursor_get_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorGetType get_type);
+
+
+ public delegate Efl.TextCursorCursor efl_text_cursor_get_api_delegate(System.IntPtr obj, Efl.TextCursorGetType get_type);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_get_api_delegate> efl_text_cursor_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_get_api_delegate>(Module, "efl_text_cursor_get");
+
+ private static Efl.TextCursorCursor text_cursor_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorGetType get_type)
+ {
+ Eina.Log.Debug("function efl_text_cursor_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetTextCursor(get_type);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), get_type);
+ }
+ }
+
+ private static efl_text_cursor_get_delegate efl_text_cursor_get_static_delegate;
+
+
+ private delegate int efl_text_cursor_position_get_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate int efl_text_cursor_position_get_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_position_get_api_delegate> efl_text_cursor_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_position_get_api_delegate>(Module, "efl_text_cursor_position_get");
+
+ private static int cursor_position_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_position_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetCursorPosition(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_position_get_delegate efl_text_cursor_position_get_static_delegate;
+
+
+ private delegate void efl_text_cursor_position_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int position);
+
+
+ public delegate void efl_text_cursor_position_set_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, int position);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_position_set_api_delegate> efl_text_cursor_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_position_set_api_delegate>(Module, "efl_text_cursor_position_set");
+
+ private static void cursor_position_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int position)
+ {
+ Eina.Log.Debug("function efl_text_cursor_position_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetCursorPosition(cur, position);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, position);
+ }
+ }
+
+ private static efl_text_cursor_position_set_delegate efl_text_cursor_position_set_static_delegate;
+
+
+ private delegate Eina.Unicode efl_text_cursor_content_get_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate Eina.Unicode efl_text_cursor_content_get_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_content_get_api_delegate> efl_text_cursor_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_content_get_api_delegate>(Module, "efl_text_cursor_content_get");
+
+ private static Eina.Unicode cursor_content_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_content_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Eina.Unicode _ret_var = default(Eina.Unicode);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetCursorContent(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_content_get_delegate efl_text_cursor_content_get_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_text_cursor_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_text_cursor_geometry_get_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_geometry_get_api_delegate> efl_text_cursor_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_geometry_get_api_delegate>(Module, "efl_text_cursor_geometry_get");
+
+ private static bool cursor_geometry_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, Efl.TextCursorType ctype, out int cx, out int cy, out int cw, out int ch, out int cx2, out int cy2, out int cw2, out int ch2)
+ {
+ Eina.Log.Debug("function efl_text_cursor_geometry_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ cx = default(int); cy = default(int); cw = default(int); ch = default(int); cx2 = default(int); cy2 = default(int); cw2 = default(int); ch2 = default(int); bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetCursorGeometry(cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, ctype, out cx, out cy, out cw, out ch, out cx2, out cy2, out cw2, out ch2);
+ }
+ }
+
+ private static efl_text_cursor_geometry_get_delegate efl_text_cursor_geometry_get_static_delegate;
+
+
+ private delegate Efl.TextCursorCursor efl_text_cursor_new_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate Efl.TextCursorCursor efl_text_cursor_new_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_new_api_delegate> efl_text_cursor_new_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_new_api_delegate>(Module, "efl_text_cursor_new");
+
+ private static Efl.TextCursorCursor cursor_new(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_text_cursor_new was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.TextCursorCursor _ret_var = default(Efl.TextCursorCursor);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).NewCursor();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_new_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_text_cursor_new_delegate efl_text_cursor_new_static_delegate;
+
+
+ private delegate void efl_text_cursor_free_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_free_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_free_api_delegate> efl_text_cursor_free_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_free_api_delegate>(Module, "efl_text_cursor_free");
+
+ private static void cursor_free(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_free was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorFree(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_free_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_free_delegate efl_text_cursor_free_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_text_cursor_equal_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_text_cursor_equal_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_equal_api_delegate> efl_text_cursor_equal_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_equal_api_delegate>(Module, "efl_text_cursor_equal");
+
+ private static bool cursor_equal(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
+ {
+ Eina.Log.Debug("function efl_text_cursor_equal was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).CursorEqual(cur1, cur2);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_equal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
+ }
+ }
+
+ private static efl_text_cursor_equal_delegate efl_text_cursor_equal_static_delegate;
+
+
+ private delegate int efl_text_cursor_compare_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2);
+
+
+ public delegate int efl_text_cursor_compare_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_compare_api_delegate> efl_text_cursor_compare_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_compare_api_delegate>(Module, "efl_text_cursor_compare");
+
+ private static int cursor_compare(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur1, Efl.TextCursorCursor cur2)
+ {
+ Eina.Log.Debug("function efl_text_cursor_compare was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).CursorCompare(cur1, cur2);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_compare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur1, cur2);
+ }
+ }
+
+ private static efl_text_cursor_compare_delegate efl_text_cursor_compare_static_delegate;
+
+
+ private delegate void efl_text_cursor_copy_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor dst, Efl.TextCursorCursor src);
+
+
+ public delegate void efl_text_cursor_copy_api_delegate(System.IntPtr obj, Efl.TextCursorCursor dst, Efl.TextCursorCursor src);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_copy_api_delegate> efl_text_cursor_copy_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_copy_api_delegate>(Module, "efl_text_cursor_copy");
+
+ private static void cursor_copy(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor dst, Efl.TextCursorCursor src)
+ {
+ Eina.Log.Debug("function efl_text_cursor_copy was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorCopy(dst, src);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_copy_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dst, src);
+ }
+ }
+
+ private static efl_text_cursor_copy_delegate efl_text_cursor_copy_static_delegate;
+
+
+ private delegate void efl_text_cursor_char_next_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_char_next_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_char_next_api_delegate> efl_text_cursor_char_next_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_char_next_api_delegate>(Module, "efl_text_cursor_char_next");
+
+ private static void cursor_char_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_char_next was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorCharNext(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_char_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_char_next_delegate efl_text_cursor_char_next_static_delegate;
+
+
+ private delegate void efl_text_cursor_char_prev_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_char_prev_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_char_prev_api_delegate> efl_text_cursor_char_prev_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_char_prev_api_delegate>(Module, "efl_text_cursor_char_prev");
+
+ private static void cursor_char_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_char_prev was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorCharPrev(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_char_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_char_prev_delegate efl_text_cursor_char_prev_static_delegate;
+
+
+ private delegate void efl_text_cursor_cluster_next_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_cluster_next_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_next_api_delegate> efl_text_cursor_cluster_next_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_next_api_delegate>(Module, "efl_text_cursor_cluster_next");
+
+ private static void cursor_cluster_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_cluster_next was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorClusterNext(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_cluster_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_cluster_next_delegate efl_text_cursor_cluster_next_static_delegate;
+
+
+ private delegate void efl_text_cursor_cluster_prev_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_cluster_prev_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_prev_api_delegate> efl_text_cursor_cluster_prev_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_prev_api_delegate>(Module, "efl_text_cursor_cluster_prev");
+
+ private static void cursor_cluster_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_cluster_prev was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorClusterPrev(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_cluster_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_cluster_prev_delegate efl_text_cursor_cluster_prev_static_delegate;
+
+
+ private delegate void efl_text_cursor_paragraph_char_first_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_paragraph_char_first_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_first_api_delegate> efl_text_cursor_paragraph_char_first_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_first_api_delegate>(Module, "efl_text_cursor_paragraph_char_first");
+
+ private static void cursor_paragraph_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_paragraph_char_first was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorParagraphCharFirst(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_paragraph_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_paragraph_char_first_delegate efl_text_cursor_paragraph_char_first_static_delegate;
+
+
+ private delegate void efl_text_cursor_paragraph_char_last_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_paragraph_char_last_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_last_api_delegate> efl_text_cursor_paragraph_char_last_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_char_last_api_delegate>(Module, "efl_text_cursor_paragraph_char_last");
+
+ private static void cursor_paragraph_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_paragraph_char_last was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorParagraphCharLast(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_paragraph_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_paragraph_char_last_delegate efl_text_cursor_paragraph_char_last_static_delegate;
+
+
+ private delegate void efl_text_cursor_word_start_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_word_start_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_word_start_api_delegate> efl_text_cursor_word_start_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_word_start_api_delegate>(Module, "efl_text_cursor_word_start");
+
+ private static void cursor_word_start(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_word_start was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorWordStart(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_word_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_word_start_delegate efl_text_cursor_word_start_static_delegate;
+
+
+ private delegate void efl_text_cursor_word_end_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_word_end_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_word_end_api_delegate> efl_text_cursor_word_end_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_word_end_api_delegate>(Module, "efl_text_cursor_word_end");
+
+ private static void cursor_word_end(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_word_end was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorWordEnd(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_word_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_word_end_delegate efl_text_cursor_word_end_static_delegate;
+
+
+ private delegate void efl_text_cursor_line_char_first_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_line_char_first_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_first_api_delegate> efl_text_cursor_line_char_first_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_first_api_delegate>(Module, "efl_text_cursor_line_char_first");
+
+ private static void cursor_line_char_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_line_char_first was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorLineCharFirst(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_line_char_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_line_char_first_delegate efl_text_cursor_line_char_first_static_delegate;
+
+
+ private delegate void efl_text_cursor_line_char_last_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_line_char_last_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_last_api_delegate> efl_text_cursor_line_char_last_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_line_char_last_api_delegate>(Module, "efl_text_cursor_line_char_last");
+
+ private static void cursor_line_char_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_line_char_last was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorLineCharLast(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_line_char_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_line_char_last_delegate efl_text_cursor_line_char_last_static_delegate;
+
+
+ private delegate void efl_text_cursor_paragraph_first_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_paragraph_first_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_first_api_delegate> efl_text_cursor_paragraph_first_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_first_api_delegate>(Module, "efl_text_cursor_paragraph_first");
+
+ private static void cursor_paragraph_first(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_paragraph_first was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorParagraphFirst(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_paragraph_first_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_paragraph_first_delegate efl_text_cursor_paragraph_first_static_delegate;
+
+
+ private delegate void efl_text_cursor_paragraph_last_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_paragraph_last_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_last_api_delegate> efl_text_cursor_paragraph_last_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_last_api_delegate>(Module, "efl_text_cursor_paragraph_last");
+
+ private static void cursor_paragraph_last(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_paragraph_last was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorParagraphLast(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_paragraph_last_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_paragraph_last_delegate efl_text_cursor_paragraph_last_static_delegate;
+
+
+ private delegate void efl_text_cursor_paragraph_next_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_paragraph_next_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_next_api_delegate> efl_text_cursor_paragraph_next_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_next_api_delegate>(Module, "efl_text_cursor_paragraph_next");
+
+ private static void cursor_paragraph_next(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_paragraph_next was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorParagraphNext(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_paragraph_next_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_paragraph_next_delegate efl_text_cursor_paragraph_next_static_delegate;
+
+
+ private delegate void efl_text_cursor_paragraph_prev_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_paragraph_prev_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_prev_api_delegate> efl_text_cursor_paragraph_prev_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_paragraph_prev_api_delegate>(Module, "efl_text_cursor_paragraph_prev");
+
+ private static void cursor_paragraph_prev(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_paragraph_prev was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorParagraphPrev(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_paragraph_prev_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_paragraph_prev_delegate efl_text_cursor_paragraph_prev_static_delegate;
+
+
+ private delegate void efl_text_cursor_line_jump_by_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int by);
+
+
+ public delegate void efl_text_cursor_line_jump_by_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, int by);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_line_jump_by_api_delegate> efl_text_cursor_line_jump_by_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_line_jump_by_api_delegate>(Module, "efl_text_cursor_line_jump_by");
+
+ private static void cursor_line_jump_by(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int by)
+ {
+ Eina.Log.Debug("function efl_text_cursor_line_jump_by was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorLineJumpBy(cur, by);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_line_jump_by_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, by);
+ }
+ }
+
+ private static efl_text_cursor_line_jump_by_delegate efl_text_cursor_line_jump_by_static_delegate;
+
+
+ private delegate void efl_text_cursor_coord_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y);
+
+
+ public delegate void efl_text_cursor_coord_set_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, int x, int y);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_coord_set_api_delegate> efl_text_cursor_coord_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_coord_set_api_delegate>(Module, "efl_text_cursor_coord_set");
+
+ private static void cursor_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
+ {
+ Eina.Log.Debug("function efl_text_cursor_coord_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetCursorCoord(cur, x, y);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, x, y);
+ }
+ }
+
+ private static efl_text_cursor_coord_set_delegate efl_text_cursor_coord_set_static_delegate;
+
+
+ private delegate void efl_text_cursor_cluster_coord_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y);
+
+
+ public delegate void efl_text_cursor_cluster_coord_set_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, int x, int y);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_coord_set_api_delegate> efl_text_cursor_cluster_coord_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_cluster_coord_set_api_delegate>(Module, "efl_text_cursor_cluster_coord_set");
+
+ private static void cursor_cluster_coord_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, int x, int y)
+ {
+ Eina.Log.Debug("function efl_text_cursor_cluster_coord_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetCursorClusterCoord(cur, x, y);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_cluster_coord_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, x, y);
+ }
+ }
+
+ private static efl_text_cursor_cluster_coord_set_delegate efl_text_cursor_cluster_coord_set_static_delegate;
+
+
+ private delegate int efl_text_cursor_text_insert_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
+
+
+ public delegate int efl_text_cursor_text_insert_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_text_insert_api_delegate> efl_text_cursor_text_insert_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_text_insert_api_delegate>(Module, "efl_text_cursor_text_insert");
+
+ private static int cursor_text_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String text)
+ {
+ Eina.Log.Debug("function efl_text_cursor_text_insert was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).CursorTextInsert(cur, text);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_cursor_text_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, text);
+ }
+ }
+
+ private static efl_text_cursor_text_insert_delegate efl_text_cursor_text_insert_static_delegate;
+
+
+ private delegate void efl_text_cursor_char_delete_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur);
+
+
+ public delegate void efl_text_cursor_char_delete_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_cursor_char_delete_api_delegate> efl_text_cursor_char_delete_ptr = new Efl.Eo.FunctionWrapper<efl_text_cursor_char_delete_api_delegate>(Module, "efl_text_cursor_char_delete");
+
+ private static void cursor_char_delete(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur)
+ {
+ Eina.Log.Debug("function efl_text_cursor_char_delete was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorCharDelete(cur);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_cursor_char_delete_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur);
+ }
+ }
+
+ private static efl_text_cursor_char_delete_delegate efl_text_cursor_char_delete_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
+ private delegate System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
+ public delegate System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate> efl_text_markup_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate>(Module, "efl_text_markup_get");
+
+ private static System.String markup_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_text_markup_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ System.String _ret_var = default(System.String);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetMarkup();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
+
+
+ private delegate void efl_text_markup_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
+
+
+ public delegate void efl_text_markup_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate> efl_text_markup_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate>(Module, "efl_text_markup_set");
+
+ private static void markup_set(System.IntPtr obj, System.IntPtr pd, System.String markup)
+ {
+ Eina.Log.Debug("function efl_text_markup_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetMarkup(markup);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), markup);
+ }
+ }
+
+ private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
+ private delegate System.String efl_text_markup_interactive_markup_range_get_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end);
+
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]
+ public delegate System.String efl_text_markup_interactive_markup_range_get_api_delegate(System.IntPtr obj, Efl.TextCursorCursor start, Efl.TextCursorCursor end);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_get_api_delegate> efl_text_markup_interactive_markup_range_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_get_api_delegate>(Module, "efl_text_markup_interactive_markup_range_get");
+
+ private static System.String markup_range_get(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end)
+ {
+ Eina.Log.Debug("function efl_text_markup_interactive_markup_range_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ System.String _ret_var = default(System.String);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetMarkupRange(start, end);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_text_markup_interactive_markup_range_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start, end);
+ }
+ }
+
+ private static efl_text_markup_interactive_markup_range_get_delegate efl_text_markup_interactive_markup_range_get_static_delegate;
+
+
+ private delegate void efl_text_markup_interactive_markup_range_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))] System.String markup);
+
+
+ public delegate void efl_text_markup_interactive_markup_range_set_api_delegate(System.IntPtr obj, Efl.TextCursorCursor start, Efl.TextCursorCursor end, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))] System.String markup);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_set_api_delegate> efl_text_markup_interactive_markup_range_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_interactive_markup_range_set_api_delegate>(Module, "efl_text_markup_interactive_markup_range_set");
+
+ private static void markup_range_set(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor start, Efl.TextCursorCursor end, System.String markup)
+ {
+ Eina.Log.Debug("function efl_text_markup_interactive_markup_range_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetMarkupRange(start, end, markup);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_markup_interactive_markup_range_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start, end, markup);
+ }
+ }
+
+ private static efl_text_markup_interactive_markup_range_set_delegate efl_text_markup_interactive_markup_range_set_static_delegate;
+
+
+ private delegate void efl_text_markup_interactive_cursor_markup_insert_delegate(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
+
+
+ public delegate void efl_text_markup_interactive_cursor_markup_insert_api_delegate(System.IntPtr obj, Efl.TextCursorCursor cur, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
+
+ public static Efl.Eo.FunctionWrapper<efl_text_markup_interactive_cursor_markup_insert_api_delegate> efl_text_markup_interactive_cursor_markup_insert_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_interactive_cursor_markup_insert_api_delegate>(Module, "efl_text_markup_interactive_cursor_markup_insert");
+
+ private static void cursor_markup_insert(System.IntPtr obj, System.IntPtr pd, Efl.TextCursorCursor cur, System.String markup)
+ {
+ Eina.Log.Debug("function efl_text_markup_interactive_cursor_markup_insert was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).CursorMarkupInsert(cur, markup);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_text_markup_interactive_cursor_markup_insert_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur, markup);
+ }
+ }
+
+ private static efl_text_markup_interactive_cursor_markup_insert_delegate efl_text_markup_interactive_cursor_markup_insert_static_delegate;
+
+
+ private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate> efl_ui_layout_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate>(Module, "efl_ui_layout_orientation_get");
+
+ private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
+ try
+ {
+ _ret_var = ((LayoutPartInvalid)ws.Target).GetOrientation();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
+
+
+ private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir);
+
+
+ public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj, Efl.Ui.LayoutOrientation dir);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate> efl_ui_layout_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate>(Module, "efl_ui_layout_orientation_set");
+
+ private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
+ {
+ Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((LayoutPartInvalid)ws.Target).SetOrientation(dir);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
+ }
+ }
+
+ private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
+
+ #pragma warning restore CA1707, CS1591, SA1300, SA1600
+
+}
+}
+}
+
+}
+
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Edje, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnVisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnPositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnSizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnHintsChangedEvt(EventArgs e)
{
var key = "_EFL_GFX_ENTITY_EVENT_HINTS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnStackingChangedEvt(EventArgs e)
{
var key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// This can be different from <see cref="Efl.Object.Parent"/> because this one is used internally for rendering and the normal parent is what the user expects to be the parent.
/// (Since EFL 1.22)</summary>
/// <returns>The parent smart object of <c>obj</c> or <c>null</c>.</returns>
- virtual public Efl.Canvas.Object GetRenderParent() {
+ virtual protected Efl.Canvas.Object GetRenderParent() {
var _ret_var = Efl.Canvas.Object.NativeMethods.efl_canvas_object_render_parent_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// This can be different from <see cref="Efl.Object.Parent"/> because this one is used internally for rendering and the normal parent is what the user expects to be the parent.
/// (Since EFL 1.22)</summary>
/// <value>The parent smart object of <c>obj</c> or <c>null</c>.</value>
- public Efl.Canvas.Object RenderParent {
+ protected Efl.Canvas.Object RenderParent {
get { return GetRenderParent(); }
}
/// <summary>This handles text paragraph direction of the given object. Even if the given object is not textblock or text, its smart child objects can inherit the paragraph direction from the given object. The default paragraph direction is <c>inherit</c>.
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_canvas_pointer_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPointer"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
Eina.Iterator<Efl.Input.Device> Seats();
/// <summary>Called when scene got focus
/// (Since EFL 1.22)</summary>
- event EventHandler<Efl.Canvas.ISceneSceneFocusInEvt_Args> SceneFocusInEvt;
+ event EventHandler SceneFocusInEvt;
/// <summary>Called when scene lost focus
/// (Since EFL 1.22)</summary>
- event EventHandler<Efl.Canvas.ISceneSceneFocusOutEvt_Args> SceneFocusOutEvt;
+ event EventHandler SceneFocusOutEvt;
/// <summary>Called when object got focus
/// (Since EFL 1.22)</summary>
event EventHandler<Efl.Canvas.ISceneObjectFocusInEvt_Args> ObjectFocusInEvt;
get ;
}
}
-///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.SceneFocusInEvt"/>.</summary>
-public class ISceneSceneFocusInEvt_Args : EventArgs {
- ///<summary>Actual event payload.</summary>
- public Efl.Input.Focus arg { get; set; }
-}
-///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.SceneFocusOutEvt"/>.</summary>
-public class ISceneSceneFocusOutEvt_Args : EventArgs {
- ///<summary>Actual event payload.</summary>
- public Efl.Input.Focus arg { get; set; }
-}
///<summary>Event argument wrapper for event <see cref="Efl.Canvas.IScene.ObjectFocusInEvt"/>.</summary>
public class ISceneObjectFocusInEvt_Args : EventArgs {
///<summary>Actual event payload.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_canvas_scene_interface_get();
/// <summary>Initializes a new instance of the <see cref="IScene"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
/// <summary>Called when scene got focus
/// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Canvas.ISceneSceneFocusInEvt_Args> SceneFocusInEvt
+ public event EventHandler SceneFocusInEvt
{
add
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
- Efl.Canvas.ISceneSceneFocusInEvt_Args args = new Efl.Canvas.ISceneSceneFocusInEvt_Args();
- args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Focus);
+ EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
}
}
///<summary>Method to raise event SceneFocusInEvt.</summary>
- public void OnSceneFocusInEvt(Efl.Canvas.ISceneSceneFocusInEvt_Args e)
+ public void OnSceneFocusInEvt(EventArgs e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
return;
}
- IntPtr info = e.arg.NativeHandle;
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// <summary>Called when scene lost focus
/// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Canvas.ISceneSceneFocusOutEvt_Args> SceneFocusOutEvt
+ public event EventHandler SceneFocusOutEvt
{
add
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
- Efl.Canvas.ISceneSceneFocusOutEvt_Args args = new Efl.Canvas.ISceneSceneFocusOutEvt_Args();
- args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Focus);
+ EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
}
}
///<summary>Method to raise event SceneFocusOutEvt.</summary>
- public void OnSceneFocusOutEvt(Efl.Canvas.ISceneSceneFocusOutEvt_Args e)
+ public void OnSceneFocusOutEvt(EventArgs e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
return;
}
- IntPtr info = e.arg.NativeHandle;
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// <summary>Called when object got focus
/// (Since EFL 1.22)</summary>
};
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnVisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnPositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnSizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Evas, key, value);
}
}
}
public void OnStackingChangedEvt(EventArgs e)
{
var key = "_EFL_GFX_ENTITY_EVENT_STACKING_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
+++ /dev/null
-#pragma warning disable CS1591
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.ComponentModel;
-namespace Efl {
-
-/// <summary>Abstract Efl class
-/// (Since EFL 1.22)</summary>
-[Efl.Class.NativeMethods]
-public abstract class Class : Efl.Eo.EoWrapper
-{
- ///<summary>Pointer to the native class description.</summary>
- public override System.IntPtr NativeClass
- {
- get
- {
- if (((object)this).GetType() == typeof(Class))
- {
- return GetEflClassStatic();
- }
- else
- {
- return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
- }
- }
- }
-
- [System.Runtime.InteropServices.DllImport(efl.Libs.Eo)] internal static extern System.IntPtr
- efl_class_class_get();
- /// <summary>Initializes a new instance of the <see cref="Class"/> class.</summary>
- /// <param name="parent">Parent instance.</param>
- public Class(Efl.Object parent= null
- ) : base(efl_class_class_get(), typeof(Class), parent)
- {
- FinishInstantiation();
- }
-
- /// <summary>Initializes a new instance of the <see cref="Class"/> class.
- /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
- /// <param name="raw">The native pointer to be wrapped.</param>
- protected Class(System.IntPtr raw) : base(raw)
- {
- }
-
- [Efl.Eo.PrivateNativeClass]
- private class ClassRealized : Class
- {
- private ClassRealized(IntPtr ptr) : base(ptr)
- {
- }
- }
- /// <summary>Initializes a new instance of the <see cref="Class"/> class.
- /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
- /// <param name="baseKlass">The pointer to the base native Eo class.</param>
- /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
- /// <param name="parent">The Efl.Object parent of this instance.</param>
- protected Class(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
- {
- }
-
- private static IntPtr GetEflClassStatic()
- {
- return Efl.Class.efl_class_class_get();
- }
- /// <summary>Wrapper for native methods and virtual method delegates.
- /// For internal use by generated code only.</summary>
- public class NativeMethods : Efl.Eo.NativeClass
- {
- /// <summary>Gets the list of Eo operations to override.</summary>
- /// <returns>The list of Eo operations to be overload.</returns>
- public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
- {
- var descs = new System.Collections.Generic.List<Efl_Op_Description>();
- return descs;
- }
- /// <summary>Returns the Eo class for the native methods of this class.</summary>
- /// <returns>The native class pointer.</returns>
- public override IntPtr GetEflClass()
- {
- return Efl.Class.efl_class_class_get();
- }
-
- #pragma warning disable CA1707, CS1591, SA1300, SA1600
-
- #pragma warning restore CA1707, CS1591, SA1300, SA1600
-
-}
-}
-}
-
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_config_interface_get();
/// <summary>Initializes a new instance of the <see cref="IConfig"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
/// If <c>profile</c> is not <c>null</c>, this will take the current in-memory config and write it out to the named <c>profile</c>. This will not change profile for the application or make other processes switch profile.</summary>
/// <param name="profile">The profile name.</param>
/// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
- virtual public bool Save(System.String profile) {
+ virtual protected bool Save(System.String profile) {
var _ret_var = Efl.ConfigGlobal.NativeMethods.efl_config_save_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// At this point it is not expected that anyone would generally use this API except if you are a desktop environment and so the user base of this API will be enlightenment itself.</summary>
/// <param name="profile">The new profile's name.</param>
/// <param name="options">Derive options detailing how to modify.</param>
- virtual public void AddProfileDerived(System.String profile, System.String options) {
+ virtual protected void AddProfileDerived(System.String profile, System.String options) {
Efl.ConfigGlobal.NativeMethods.efl_config_profile_derived_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile, options);
Eina.Error.RaiseIfUnhandledException();
}
///
/// At this point it is not expected that anyone would generally use this API except if you are a desktop environment and so the user base of this API will be enlightenment itself.</summary>
/// <param name="profile">The name of the profile that is to be deleted.</param>
- virtual public void DelProfileDerived(System.String profile) {
+ virtual protected void DelProfileDerived(System.String profile) {
Efl.ConfigGlobal.NativeMethods.efl_config_profile_derived_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),profile);
Eina.Error.RaiseIfUnhandledException();
}
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_container_interface_get();
/// <summary>Initializes a new instance of the <see cref="IContainer"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_content_interface_get();
/// <summary>Initializes a new instance of the <see cref="IContent"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_control_interface_get();
/// <summary>Initializes a new instance of the <see cref="IControl"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((ICommandLineConcrete)ws.Target).GetCommand();
+ _ret_var = ((ICommandLine)ws.Target).GetCommand();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((ICommandLineConcrete)ws.Target).SetCommandArray(_in_array);
+ _ret_var = ((ICommandLine)ws.Target).SetCommandArray(_in_array);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((ICommandLineConcrete)ws.Target).SetCommandString(str);
+ _ret_var = ((ICommandLine)ws.Target).SetCommandString(str);
}
catch (Exception e)
{
Eina.Accessor<System.String> _ret_var = default(Eina.Accessor<System.String>);
try
{
- _ret_var = ((ICommandLineConcrete)ws.Target).CommandAccess();
+ _ret_var = ((ICommandLine)ws.Target).CommandAccess();
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_duplicate_interface_get();
/// <summary>Initializes a new instance of the <see cref="IDuplicate"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnClosedEvt(EventArgs e)
{
var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
{
var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_READER_EVENT_EOS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_READER_EVENT_EOS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnEosEvt(EventArgs e)
{
var key = "_EFL_IO_READER_EVENT_EOS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
{
var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_file_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IFile"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
Eina.File _ret_var = default(Eina.File);
try
{
- _ret_var = ((IFileConcrete)ws.Target).GetMmap();
+ _ret_var = ((IFile)ws.Target).GetMmap();
}
catch (Exception e)
{
Eina.Error _ret_var = default(Eina.Error);
try
{
- _ret_var = ((IFileConcrete)ws.Target).SetMmap(f);
+ _ret_var = ((IFile)ws.Target).SetMmap(f);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IFileConcrete)ws.Target).GetFile();
+ _ret_var = ((IFile)ws.Target).GetFile();
}
catch (Exception e)
{
Eina.Error _ret_var = default(Eina.Error);
try
{
- _ret_var = ((IFileConcrete)ws.Target).SetFile(file);
+ _ret_var = ((IFile)ws.Target).SetFile(file);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IFileConcrete)ws.Target).GetKey();
+ _ret_var = ((IFile)ws.Target).GetKey();
}
catch (Exception e)
{
try
{
- ((IFileConcrete)ws.Target).SetKey(key);
+ ((IFile)ws.Target).SetKey(key);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IFileConcrete)ws.Target).GetLoaded();
+ _ret_var = ((IFile)ws.Target).GetLoaded();
}
catch (Exception e)
{
Eina.Error _ret_var = default(Eina.Error);
try
{
- _ret_var = ((IFileConcrete)ws.Target).Load();
+ _ret_var = ((IFile)ws.Target).Load();
}
catch (Exception e)
{
try
{
- ((IFileConcrete)ws.Target).Unload();
+ ((IFile)ws.Target).Unload();
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_file_save_interface_get();
/// <summary>Initializes a new instance of the <see cref="IFileSave"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_arrangement_interface_get();
/// <summary>Initializes a new instance of the <see cref="IArrangement"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_blur_interface_get();
/// <summary>Initializes a new instance of the <see cref="IBlur"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_buffer_interface_get();
/// <summary>Initializes a new instance of the <see cref="IBuffer"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_color_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IColor"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
r = default(int); g = default(int); b = default(int); a = default(int);
try
{
- ((IColorConcrete)ws.Target).GetColor(out r, out g, out b, out a);
+ ((IColor)ws.Target).GetColor(out r, out g, out b, out a);
}
catch (Exception e)
{
try
{
- ((IColorConcrete)ws.Target).SetColor(r, g, b, a);
+ ((IColor)ws.Target).SetColor(r, g, b, a);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IColorConcrete)ws.Target).GetColorCode();
+ _ret_var = ((IColor)ws.Target).GetColorCode();
}
catch (Exception e)
{
try
{
- ((IColorConcrete)ws.Target).SetColorCode(colorcode);
+ ((IColor)ws.Target).SetColorCode(colorcode);
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_color_class_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IColorClass"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
r = default(int); g = default(int); b = default(int); a = default(int); bool _ret_var = default(bool);
try
{
- _ret_var = ((IColorClassConcrete)ws.Target).GetColorClass(color_class, layer, out r, out g, out b, out a);
+ _ret_var = ((IColorClass)ws.Target).GetColorClass(color_class, layer, out r, out g, out b, out a);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IColorClassConcrete)ws.Target).SetColorClass(color_class, layer, r, g, b, a);
+ _ret_var = ((IColorClass)ws.Target).SetColorClass(color_class, layer, r, g, b, a);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IColorClassConcrete)ws.Target).GetColorClassCode(color_class, layer);
+ _ret_var = ((IColorClass)ws.Target).GetColorClassCode(color_class, layer);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IColorClassConcrete)ws.Target).SetColorClassCode(color_class, layer, colorcode);
+ _ret_var = ((IColorClass)ws.Target).SetColorClassCode(color_class, layer, colorcode);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IColorClassConcrete)ws.Target).GetColorClassDescription(color_class);
+ _ret_var = ((IColorClass)ws.Target).GetColorClassDescription(color_class);
}
catch (Exception e)
{
try
{
- ((IColorClassConcrete)ws.Target).DelColorClass(color_class);
+ ((IColorClass)ws.Target).DelColorClass(color_class);
}
catch (Exception e)
{
try
{
- ((IColorClassConcrete)ws.Target).ClearColorClass();
+ ((IColorClass)ws.Target).ClearColorClass();
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_entity_interface_get();
/// <summary>Initializes a new instance of the <see cref="IEntity"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_fill_interface_get();
/// <summary>Initializes a new instance of the <see cref="IFill"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_filter_interface_get();
/// <summary>Initializes a new instance of the <see cref="IFilter"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_frame_controller_interface_get();
/// <summary>Initializes a new instance of the <see cref="IFrameController"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_gradient_interface_get();
/// <summary>Initializes a new instance of the <see cref="IGradient"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_gradient_linear_interface_get();
/// <summary>Initializes a new instance of the <see cref="IGradientLinear"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_gradient_radial_interface_get();
/// <summary>Initializes a new instance of the <see cref="IGradientRadial"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_hint_interface_get();
/// <summary>Initializes a new instance of the <see cref="IHint"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_image_interface_get();
/// <summary>Initializes a new instance of the <see cref="IImage"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_image_load_controller_interface_get();
/// <summary>Initializes a new instance of the <see cref="IImageLoadController"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_image_orientable_interface_get();
/// <summary>Initializes a new instance of the <see cref="IImageOrientable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
int _ret_var = default(int);
try
{
- _ret_var = ((IMappingConcrete)ws.Target).GetMappingPointCount();
+ _ret_var = ((IMapping)ws.Target).GetMappingPointCount();
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).SetMappingPointCount(count);
+ ((IMapping)ws.Target).SetMappingPointCount(count);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IMappingConcrete)ws.Target).GetMappingClockwise();
+ _ret_var = ((IMapping)ws.Target).GetMappingClockwise();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IMappingConcrete)ws.Target).GetMappingSmooth();
+ _ret_var = ((IMapping)ws.Target).GetMappingSmooth();
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).SetMappingSmooth(smooth);
+ ((IMapping)ws.Target).SetMappingSmooth(smooth);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IMappingConcrete)ws.Target).GetMappingAlpha();
+ _ret_var = ((IMapping)ws.Target).GetMappingAlpha();
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).SetMappingAlpha(alpha);
+ ((IMapping)ws.Target).SetMappingAlpha(alpha);
}
catch (Exception e)
{
x = default(double); y = default(double); z = default(double);
try
{
- ((IMappingConcrete)ws.Target).GetMappingCoordAbsolute(idx, out x, out y, out z);
+ ((IMapping)ws.Target).GetMappingCoordAbsolute(idx, out x, out y, out z);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).SetMappingCoordAbsolute(idx, x, y, z);
+ ((IMapping)ws.Target).SetMappingCoordAbsolute(idx, x, y, z);
}
catch (Exception e)
{
u = default(double); v = default(double);
try
{
- ((IMappingConcrete)ws.Target).GetMappingUv(idx, out u, out v);
+ ((IMapping)ws.Target).GetMappingUv(idx, out u, out v);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).SetMappingUv(idx, u, v);
+ ((IMapping)ws.Target).SetMappingUv(idx, u, v);
}
catch (Exception e)
{
r = default(int); g = default(int); b = default(int); a = default(int);
try
{
- ((IMappingConcrete)ws.Target).GetMappingColor(idx, out r, out g, out b, out a);
+ ((IMapping)ws.Target).GetMappingColor(idx, out r, out g, out b, out a);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).SetMappingColor(idx, r, g, b, a);
+ ((IMapping)ws.Target).SetMappingColor(idx, r, g, b, a);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IMappingConcrete)ws.Target).HasMapping();
+ _ret_var = ((IMapping)ws.Target).HasMapping();
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).ResetMapping();
+ ((IMapping)ws.Target).ResetMapping();
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Translate(dx, dy, dz);
+ ((IMapping)ws.Target).Translate(dx, dy, dz);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Rotate(degrees, pivot, cx, cy);
+ ((IMapping)ws.Target).Rotate(degrees, pivot, cx, cy);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Rotate3d(dx, dy, dz, pivot, cx, cy, cz);
+ ((IMapping)ws.Target).Rotate3d(dx, dy, dz, pivot, cx, cy, cz);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).RotateQuat(qx, qy, qz, qw, pivot, cx, cy, cz);
+ ((IMapping)ws.Target).RotateQuat(qx, qy, qz, qw, pivot, cx, cy, cz);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Zoom(zoomx, zoomy, pivot, cx, cy);
+ ((IMapping)ws.Target).Zoom(zoomx, zoomy, pivot, cx, cy);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Lighting3d(pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
+ ((IMapping)ws.Target).Lighting3d(pivot, lx, ly, lz, lr, lg, lb, ar, ag, ab);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Perspective3d(pivot, px, py, z0, foc);
+ ((IMapping)ws.Target).Perspective3d(pivot, px, py, z0, foc);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).RotateAbsolute(degrees, cx, cy);
+ ((IMapping)ws.Target).RotateAbsolute(degrees, cx, cy);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Rotate3dAbsolute(dx, dy, dz, cx, cy, cz);
+ ((IMapping)ws.Target).Rotate3dAbsolute(dx, dy, dz, cx, cy, cz);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).RotateQuatAbsolute(qx, qy, qz, qw, cx, cy, cz);
+ ((IMapping)ws.Target).RotateQuatAbsolute(qx, qy, qz, qw, cx, cy, cz);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).ZoomAbsolute(zoomx, zoomy, cx, cy);
+ ((IMapping)ws.Target).ZoomAbsolute(zoomx, zoomy, cx, cy);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Lighting3dAbsolute(lx, ly, lz, lr, lg, lb, ar, ag, ab);
+ ((IMapping)ws.Target).Lighting3dAbsolute(lx, ly, lz, lr, lg, lb, ar, ag, ab);
}
catch (Exception e)
{
try
{
- ((IMappingConcrete)ws.Target).Perspective3dAbsolute(px, py, z0, foc);
+ ((IMapping)ws.Target).Perspective3dAbsolute(px, py, z0, foc);
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_path_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IPath"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
try
{
- ((IPathConcrete)ws.Target).GetPath(out _out_op, out _out_points);
+ ((IPath)ws.Target).GetPath(out _out_op, out _out_points);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).SetPath(_in_op, _in_points);
+ ((IPath)ws.Target).SetPath(_in_op, _in_points);
}
catch (Exception e)
{
commands = default(uint); points = default(uint);
try
{
- ((IPathConcrete)ws.Target).GetLength(out commands, out points);
+ ((IPath)ws.Target).GetLength(out commands, out points);
}
catch (Exception e)
{
x = default(double); y = default(double);
try
{
- ((IPathConcrete)ws.Target).GetCurrent(out x, out y);
+ ((IPath)ws.Target).GetCurrent(out x, out y);
}
catch (Exception e)
{
x = default(double); y = default(double);
try
{
- ((IPathConcrete)ws.Target).GetCurrentCtrl(out x, out y);
+ ((IPath)ws.Target).GetCurrentCtrl(out x, out y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).CopyFrom(dup_from);
+ ((IPath)ws.Target).CopyFrom(dup_from);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).GetBounds(out _out_r);
+ ((IPath)ws.Target).GetBounds(out _out_r);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).Reset();
+ ((IPath)ws.Target).Reset();
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendMoveTo(x, y);
+ ((IPath)ws.Target).AppendMoveTo(x, y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendLineTo(x, y);
+ ((IPath)ws.Target).AppendLineTo(x, y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendQuadraticTo(x, y, ctrl_x, ctrl_y);
+ ((IPath)ws.Target).AppendQuadraticTo(x, y, ctrl_x, ctrl_y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendSquadraticTo(x, y);
+ ((IPath)ws.Target).AppendSquadraticTo(x, y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendCubicTo(ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
+ ((IPath)ws.Target).AppendCubicTo(ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendScubicTo(x, y, ctrl_x, ctrl_y);
+ ((IPath)ws.Target).AppendScubicTo(x, y, ctrl_x, ctrl_y);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendArcTo(x, y, rx, ry, angle, large_arc, sweep);
+ ((IPath)ws.Target).AppendArcTo(x, y, rx, ry, angle, large_arc, sweep);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendArc(x, y, w, h, start_angle, sweep_length);
+ ((IPath)ws.Target).AppendArc(x, y, w, h, start_angle, sweep_length);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).CloseAppend();
+ ((IPath)ws.Target).CloseAppend();
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendCircle(x, y, radius);
+ ((IPath)ws.Target).AppendCircle(x, y, radius);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendRect(x, y, w, h, rx, ry);
+ ((IPath)ws.Target).AppendRect(x, y, w, h, rx, ry);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).AppendSvgPath(svg_path_data);
+ ((IPath)ws.Target).AppendSvgPath(svg_path_data);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IPathConcrete)ws.Target).Interpolate(from, to, pos_map);
+ _ret_var = ((IPath)ws.Target).Interpolate(from, to, pos_map);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IPathConcrete)ws.Target).EqualCommands(with);
+ _ret_var = ((IPath)ws.Target).EqualCommands(with);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).Reserve(cmd_count, pts_count);
+ ((IPath)ws.Target).Reserve(cmd_count, pts_count);
}
catch (Exception e)
{
try
{
- ((IPathConcrete)ws.Target).Commit();
+ ((IPath)ws.Target).Commit();
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_shape_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IShape"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
double _ret_var = default(double);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).GetStrokeScale();
+ _ret_var = ((IShape)ws.Target).GetStrokeScale();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeScale(s);
+ ((IShape)ws.Target).SetStrokeScale(s);
}
catch (Exception e)
{
r = default(int); g = default(int); b = default(int); a = default(int);
try
{
- ((IShapeConcrete)ws.Target).GetStrokeColor(out r, out g, out b, out a);
+ ((IShape)ws.Target).GetStrokeColor(out r, out g, out b, out a);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeColor(r, g, b, a);
+ ((IShape)ws.Target).SetStrokeColor(r, g, b, a);
}
catch (Exception e)
{
double _ret_var = default(double);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).GetStrokeWidth();
+ _ret_var = ((IShape)ws.Target).GetStrokeWidth();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeWidth(w);
+ ((IShape)ws.Target).SetStrokeWidth(w);
}
catch (Exception e)
{
double _ret_var = default(double);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).GetStrokeLocation();
+ _ret_var = ((IShape)ws.Target).GetStrokeLocation();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeLocation(centered);
+ ((IShape)ws.Target).SetStrokeLocation(centered);
}
catch (Exception e)
{
length = default(uint);
try
{
- ((IShapeConcrete)ws.Target).GetStrokeDash(out _out_dash, out length);
+ ((IShape)ws.Target).GetStrokeDash(out _out_dash, out length);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeDash(ref _in_dash, length);
+ ((IShape)ws.Target).SetStrokeDash(ref _in_dash, length);
}
catch (Exception e)
{
Efl.Gfx.Cap _ret_var = default(Efl.Gfx.Cap);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).GetStrokeCap();
+ _ret_var = ((IShape)ws.Target).GetStrokeCap();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeCap(c);
+ ((IShape)ws.Target).SetStrokeCap(c);
}
catch (Exception e)
{
Efl.Gfx.Join _ret_var = default(Efl.Gfx.Join);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).GetStrokeJoin();
+ _ret_var = ((IShape)ws.Target).GetStrokeJoin();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetStrokeJoin(j);
+ ((IShape)ws.Target).SetStrokeJoin(j);
}
catch (Exception e)
{
Efl.Gfx.FillRule _ret_var = default(Efl.Gfx.FillRule);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).GetFillRule();
+ _ret_var = ((IShape)ws.Target).GetFillRule();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetFillRule(fill_rule);
+ ((IShape)ws.Target).SetFillRule(fill_rule);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).GetPath(out _out_op, out _out_points);
+ ((IShape)ws.Target).GetPath(out _out_op, out _out_points);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).SetPath(_in_op, _in_points);
+ ((IShape)ws.Target).SetPath(_in_op, _in_points);
}
catch (Exception e)
{
commands = default(uint); points = default(uint);
try
{
- ((IShapeConcrete)ws.Target).GetLength(out commands, out points);
+ ((IShape)ws.Target).GetLength(out commands, out points);
}
catch (Exception e)
{
x = default(double); y = default(double);
try
{
- ((IShapeConcrete)ws.Target).GetCurrent(out x, out y);
+ ((IShape)ws.Target).GetCurrent(out x, out y);
}
catch (Exception e)
{
x = default(double); y = default(double);
try
{
- ((IShapeConcrete)ws.Target).GetCurrentCtrl(out x, out y);
+ ((IShape)ws.Target).GetCurrentCtrl(out x, out y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).CopyFrom(dup_from);
+ ((IShape)ws.Target).CopyFrom(dup_from);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).GetBounds(out _out_r);
+ ((IShape)ws.Target).GetBounds(out _out_r);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).Reset();
+ ((IShape)ws.Target).Reset();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendMoveTo(x, y);
+ ((IShape)ws.Target).AppendMoveTo(x, y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendLineTo(x, y);
+ ((IShape)ws.Target).AppendLineTo(x, y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendQuadraticTo(x, y, ctrl_x, ctrl_y);
+ ((IShape)ws.Target).AppendQuadraticTo(x, y, ctrl_x, ctrl_y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendSquadraticTo(x, y);
+ ((IShape)ws.Target).AppendSquadraticTo(x, y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendCubicTo(ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
+ ((IShape)ws.Target).AppendCubicTo(ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendScubicTo(x, y, ctrl_x, ctrl_y);
+ ((IShape)ws.Target).AppendScubicTo(x, y, ctrl_x, ctrl_y);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendArcTo(x, y, rx, ry, angle, large_arc, sweep);
+ ((IShape)ws.Target).AppendArcTo(x, y, rx, ry, angle, large_arc, sweep);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendArc(x, y, w, h, start_angle, sweep_length);
+ ((IShape)ws.Target).AppendArc(x, y, w, h, start_angle, sweep_length);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).CloseAppend();
+ ((IShape)ws.Target).CloseAppend();
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendCircle(x, y, radius);
+ ((IShape)ws.Target).AppendCircle(x, y, radius);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendRect(x, y, w, h, rx, ry);
+ ((IShape)ws.Target).AppendRect(x, y, w, h, rx, ry);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).AppendSvgPath(svg_path_data);
+ ((IShape)ws.Target).AppendSvgPath(svg_path_data);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).Interpolate(from, to, pos_map);
+ _ret_var = ((IShape)ws.Target).Interpolate(from, to, pos_map);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IShapeConcrete)ws.Target).EqualCommands(with);
+ _ret_var = ((IShape)ws.Target).EqualCommands(with);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).Reserve(cmd_count, pts_count);
+ ((IShape)ws.Target).Reserve(cmd_count, pts_count);
}
catch (Exception e)
{
try
{
- ((IShapeConcrete)ws.Target).Commit();
+ ((IShape)ws.Target).Commit();
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_size_class_interface_get();
/// <summary>Initializes a new instance of the <see cref="ISizeClass"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_stack_interface_get();
/// <summary>Initializes a new instance of the <see cref="IStack"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_text_class_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextClass"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_gfx_view_interface_get();
/// <summary>Initializes a new instance of the <see cref="IView"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_input_device_class_get();
/// <summary>Initializes a new instance of the <see cref="Device"/> class.</summary>
/// <param name="parent">Parent instance.</param>
Efl.Input.Device.NativeMethods.efl_input_device_seat_id_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),id);
Eina.Error.RaiseIfUnhandledException();
}
+ /// <summary>The number of pointer devices in this seat.
+ /// Pointer devices are the ones whose <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>. In case this device is not of the type <c>seat</c>, -1 is returned.</summary>
+ /// <returns>The number of pointer devices.</returns>
+ virtual public int GetPointerDeviceCount() {
+ var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_pointer_device_count_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary><c>true</c> if <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>.</summary>
+ /// <returns><c>true</c> if the device has pointing capabilities.</returns>
+ virtual public bool GetIsPointerType() {
+ var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_is_pointer_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
/// <summary>Lists the children attached to this device.
/// This is only meaningful with seat devices, as they are groups of real input devices.</summary>
/// <returns>List of device children</returns>
Eina.Error.RaiseIfUnhandledException();
return new Eina.Iterator<Efl.Input.Device>(_ret_var, true, false);
}
- /// <summary>Determine whether a device has pointer capabilities.
- /// Returns 1 for Mouse, Touch, Pen, Pointer, and Wand type devices.
- ///
- /// If a seat device is passed returns the number of pointer devices in the seat.</summary>
- /// <returns>Pointer caps</returns>
- virtual public uint HasPointerCaps() {
- var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_has_pointer_caps_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
/// <summary>Device type property</summary>
/// <value>Input device class</value>
public Efl.Input.DeviceType DeviceType {
get { return GetSeatId(); }
set { SetSeatId(value); }
}
+ /// <summary>The number of pointer devices in this seat.
+ /// Pointer devices are the ones whose <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>. In case this device is not of the type <c>seat</c>, -1 is returned.</summary>
+ /// <value>The number of pointer devices.</value>
+ public int PointerDeviceCount {
+ get { return GetPointerDeviceCount(); }
+ }
+ /// <summary><c>true</c> if <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>.</summary>
+ /// <value><c>true</c> if the device has pointing capabilities.</value>
+ public bool IsPointerType {
+ get { return GetIsPointerType(); }
+ }
private static IntPtr GetEflClassStatic()
{
return Efl.Input.Device.efl_input_device_class_get();
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_seat_id_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_seat_id_set_static_delegate) });
}
- if (efl_input_device_children_iterate_static_delegate == null)
+ if (efl_input_device_pointer_device_count_get_static_delegate == null)
{
- efl_input_device_children_iterate_static_delegate = new efl_input_device_children_iterate_delegate(children_iterate);
+ efl_input_device_pointer_device_count_get_static_delegate = new efl_input_device_pointer_device_count_get_delegate(pointer_device_count_get);
}
- if (methods.FirstOrDefault(m => m.Name == "ChildrenIterate") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetPointerDeviceCount") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_children_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_children_iterate_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_pointer_device_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_pointer_device_count_get_static_delegate) });
}
- if (efl_input_device_has_pointer_caps_static_delegate == null)
+ if (efl_input_device_is_pointer_type_get_static_delegate == null)
{
- efl_input_device_has_pointer_caps_static_delegate = new efl_input_device_has_pointer_caps_delegate(has_pointer_caps);
+ efl_input_device_is_pointer_type_get_static_delegate = new efl_input_device_is_pointer_type_get_delegate(is_pointer_type_get);
}
- if (methods.FirstOrDefault(m => m.Name == "HasPointerCaps") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetIsPointerType") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_has_pointer_caps"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_has_pointer_caps_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_is_pointer_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_is_pointer_type_get_static_delegate) });
+ }
+
+ if (efl_input_device_children_iterate_static_delegate == null)
+ {
+ efl_input_device_children_iterate_static_delegate = new efl_input_device_children_iterate_delegate(children_iterate);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "ChildrenIterate") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_children_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_children_iterate_static_delegate) });
}
descs.AddRange(base.GetEoOps(type));
private static efl_input_device_seat_id_set_delegate efl_input_device_seat_id_set_static_delegate;
- private delegate System.IntPtr efl_input_device_children_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
+ private delegate int efl_input_device_pointer_device_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
- public delegate System.IntPtr efl_input_device_children_iterate_api_delegate(System.IntPtr obj);
+ public delegate int efl_input_device_pointer_device_count_get_api_delegate(System.IntPtr obj);
- public static Efl.Eo.FunctionWrapper<efl_input_device_children_iterate_api_delegate> efl_input_device_children_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_children_iterate_api_delegate>(Module, "efl_input_device_children_iterate");
+ public static Efl.Eo.FunctionWrapper<efl_input_device_pointer_device_count_get_api_delegate> efl_input_device_pointer_device_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_pointer_device_count_get_api_delegate>(Module, "efl_input_device_pointer_device_count_get");
- private static System.IntPtr children_iterate(System.IntPtr obj, System.IntPtr pd)
+ private static int pointer_device_count_get(System.IntPtr obj, System.IntPtr pd)
{
- Eina.Log.Debug("function efl_input_device_children_iterate was called");
+ Eina.Log.Debug("function efl_input_device_pointer_device_count_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- Eina.Iterator<Efl.Input.Device> _ret_var = default(Eina.Iterator<Efl.Input.Device>);
+ int _ret_var = default(int);
try
{
- _ret_var = ((Device)ws.Target).ChildrenIterate();
+ _ret_var = ((Device)ws.Target).GetPointerDeviceCount();
}
catch (Exception e)
{
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
- _ret_var.Own = false; return _ret_var.Handle;
+ return _ret_var;
}
else
{
- return efl_input_device_children_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ return efl_input_device_pointer_device_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
- private static efl_input_device_children_iterate_delegate efl_input_device_children_iterate_static_delegate;
+ private static efl_input_device_pointer_device_count_get_delegate efl_input_device_pointer_device_count_get_static_delegate;
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ private delegate bool efl_input_device_is_pointer_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return: MarshalAs(UnmanagedType.U1)]
+ public delegate bool efl_input_device_is_pointer_type_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_input_device_is_pointer_type_get_api_delegate> efl_input_device_is_pointer_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_is_pointer_type_get_api_delegate>(Module, "efl_input_device_is_pointer_type_get");
+
+ private static bool is_pointer_type_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_input_device_is_pointer_type_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ bool _ret_var = default(bool);
+ try
+ {
+ _ret_var = ((Device)ws.Target).GetIsPointerType();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_input_device_is_pointer_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_input_device_is_pointer_type_get_delegate efl_input_device_is_pointer_type_get_static_delegate;
- private delegate uint efl_input_device_has_pointer_caps_delegate(System.IntPtr obj, System.IntPtr pd);
+ private delegate System.IntPtr efl_input_device_children_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
- public delegate uint efl_input_device_has_pointer_caps_api_delegate(System.IntPtr obj);
+ public delegate System.IntPtr efl_input_device_children_iterate_api_delegate(System.IntPtr obj);
- public static Efl.Eo.FunctionWrapper<efl_input_device_has_pointer_caps_api_delegate> efl_input_device_has_pointer_caps_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_has_pointer_caps_api_delegate>(Module, "efl_input_device_has_pointer_caps");
+ public static Efl.Eo.FunctionWrapper<efl_input_device_children_iterate_api_delegate> efl_input_device_children_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_children_iterate_api_delegate>(Module, "efl_input_device_children_iterate");
- private static uint has_pointer_caps(System.IntPtr obj, System.IntPtr pd)
+ private static System.IntPtr children_iterate(System.IntPtr obj, System.IntPtr pd)
{
- Eina.Log.Debug("function efl_input_device_has_pointer_caps was called");
+ Eina.Log.Debug("function efl_input_device_children_iterate was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- uint _ret_var = default(uint);
+ Eina.Iterator<Efl.Input.Device> _ret_var = default(Eina.Iterator<Efl.Input.Device>);
try
{
- _ret_var = ((Device)ws.Target).HasPointerCaps();
+ _ret_var = ((Device)ws.Target).ChildrenIterate();
}
catch (Exception e)
{
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
- return _ret_var;
+ _ret_var.Own = false; return _ret_var.Handle;
}
else
{
- return efl_input_device_has_pointer_caps_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ return efl_input_device_children_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
- private static efl_input_device_has_pointer_caps_delegate efl_input_device_has_pointer_caps_static_delegate;
+ private static efl_input_device_children_iterate_delegate efl_input_device_children_iterate_static_delegate;
#pragma warning restore CA1707, CS1591, SA1300, SA1600
double _ret_var = default(double);
try
{
- _ret_var = ((IEventConcrete)ws.Target).GetTimestamp();
+ _ret_var = ((IEvent)ws.Target).GetTimestamp();
}
catch (Exception e)
{
try
{
- ((IEventConcrete)ws.Target).SetTimestamp(ms);
+ ((IEvent)ws.Target).SetTimestamp(ms);
}
catch (Exception e)
{
Efl.Input.Device _ret_var = default(Efl.Input.Device);
try
{
- _ret_var = ((IEventConcrete)ws.Target).GetDevice();
+ _ret_var = ((IEvent)ws.Target).GetDevice();
}
catch (Exception e)
{
try
{
- ((IEventConcrete)ws.Target).SetDevice(dev);
+ ((IEvent)ws.Target).SetDevice(dev);
}
catch (Exception e)
{
Efl.Input.Flags _ret_var = default(Efl.Input.Flags);
try
{
- _ret_var = ((IEventConcrete)ws.Target).GetEventFlags();
+ _ret_var = ((IEvent)ws.Target).GetEventFlags();
}
catch (Exception e)
{
try
{
- ((IEventConcrete)ws.Target).SetEventFlags(flags);
+ ((IEvent)ws.Target).SetEventFlags(flags);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IEventConcrete)ws.Target).GetProcessed();
+ _ret_var = ((IEvent)ws.Target).GetProcessed();
}
catch (Exception e)
{
try
{
- ((IEventConcrete)ws.Target).SetProcessed(val);
+ ((IEvent)ws.Target).SetProcessed(val);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IEventConcrete)ws.Target).GetScrolling();
+ _ret_var = ((IEvent)ws.Target).GetScrolling();
}
catch (Exception e)
{
try
{
- ((IEventConcrete)ws.Target).SetScrolling(val);
+ ((IEvent)ws.Target).SetScrolling(val);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IEventConcrete)ws.Target).GetFake();
+ _ret_var = ((IEvent)ws.Target).GetFake();
}
catch (Exception e)
{
try
{
- ((IEventConcrete)ws.Target).Reset();
+ ((IEvent)ws.Target).Reset();
}
catch (Exception e)
{
Efl.IDuplicate _ret_var = default(Efl.IDuplicate);
try
{
- _ret_var = ((IEventConcrete)ws.Target).Duplicate();
+ _ret_var = ((IEvent)ws.Target).Duplicate();
}
catch (Exception e)
{
/// <summary>A UTF8 string if this keystroke has modified a string in the middle of being composed.
/// Note: This string replaces the previous one</summary>
/// <returns>Composed key string in UTF8</returns>
- virtual public System.String GetCompose() {
- var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_compose_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ virtual public System.String GetComposeString() {
+ var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_compose_string_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
/// <summary>A UTF8 string if this keystroke has modified a string in the middle of being composed.
/// Note: This string replaces the previous one</summary>
/// <param name="val">Composed key string in UTF8</param>
- virtual public void SetCompose(System.String val) {
- Efl.Input.Key.NativeMethods.efl_input_key_compose_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
+ virtual public void SetComposeString(System.String val) {
+ Efl.Input.Key.NativeMethods.efl_input_key_compose_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Key scan code numeric value.</summary>
/// <summary>A UTF8 string if this keystroke has modified a string in the middle of being composed.
/// Note: This string replaces the previous one</summary>
/// <value>Composed key string in UTF8</value>
- public System.String Compose {
- get { return GetCompose(); }
- set { SetCompose(value); }
+ public System.String ComposeString {
+ get { return GetComposeString(); }
+ set { SetComposeString(value); }
}
/// <summary>Key scan code numeric value.</summary>
/// <value>Key scan code</value>
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_string_set_static_delegate) });
}
- if (efl_input_key_compose_get_static_delegate == null)
+ if (efl_input_key_compose_string_get_static_delegate == null)
{
- efl_input_key_compose_get_static_delegate = new efl_input_key_compose_get_delegate(compose_get);
+ efl_input_key_compose_string_get_static_delegate = new efl_input_key_compose_string_get_delegate(compose_string_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetCompose") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetComposeString") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_compose_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_compose_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_compose_string_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_compose_string_get_static_delegate) });
}
- if (efl_input_key_compose_set_static_delegate == null)
+ if (efl_input_key_compose_string_set_static_delegate == null)
{
- efl_input_key_compose_set_static_delegate = new efl_input_key_compose_set_delegate(compose_set);
+ efl_input_key_compose_string_set_static_delegate = new efl_input_key_compose_string_set_delegate(compose_string_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetCompose") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetComposeString") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_compose_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_compose_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_compose_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_compose_string_set_static_delegate) });
}
if (efl_input_key_code_get_static_delegate == null)
private static efl_input_key_string_set_delegate efl_input_key_string_set_static_delegate;
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
- private delegate System.String efl_input_key_compose_get_delegate(System.IntPtr obj, System.IntPtr pd);
+ private delegate System.String efl_input_key_compose_string_get_delegate(System.IntPtr obj, System.IntPtr pd);
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
- public delegate System.String efl_input_key_compose_get_api_delegate(System.IntPtr obj);
+ public delegate System.String efl_input_key_compose_string_get_api_delegate(System.IntPtr obj);
- public static Efl.Eo.FunctionWrapper<efl_input_key_compose_get_api_delegate> efl_input_key_compose_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_compose_get_api_delegate>(Module, "efl_input_key_compose_get");
+ public static Efl.Eo.FunctionWrapper<efl_input_key_compose_string_get_api_delegate> efl_input_key_compose_string_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_compose_string_get_api_delegate>(Module, "efl_input_key_compose_string_get");
- private static System.String compose_get(System.IntPtr obj, System.IntPtr pd)
+ private static System.String compose_string_get(System.IntPtr obj, System.IntPtr pd)
{
- Eina.Log.Debug("function efl_input_key_compose_get was called");
+ Eina.Log.Debug("function efl_input_key_compose_string_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((Key)ws.Target).GetCompose();
+ _ret_var = ((Key)ws.Target).GetComposeString();
}
catch (Exception e)
{
}
else
{
- return efl_input_key_compose_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ return efl_input_key_compose_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
- private static efl_input_key_compose_get_delegate efl_input_key_compose_get_static_delegate;
+ private static efl_input_key_compose_string_get_delegate efl_input_key_compose_string_get_static_delegate;
- private delegate void efl_input_key_compose_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
+ private delegate void efl_input_key_compose_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
- public delegate void efl_input_key_compose_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
+ public delegate void efl_input_key_compose_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
- public static Efl.Eo.FunctionWrapper<efl_input_key_compose_set_api_delegate> efl_input_key_compose_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_compose_set_api_delegate>(Module, "efl_input_key_compose_set");
+ public static Efl.Eo.FunctionWrapper<efl_input_key_compose_string_set_api_delegate> efl_input_key_compose_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_compose_string_set_api_delegate>(Module, "efl_input_key_compose_string_set");
- private static void compose_set(System.IntPtr obj, System.IntPtr pd, System.String val)
+ private static void compose_string_set(System.IntPtr obj, System.IntPtr pd, System.String val)
{
- Eina.Log.Debug("function efl_input_key_compose_set was called");
+ Eina.Log.Debug("function efl_input_key_compose_string_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((Key)ws.Target).SetCompose(val);
+ ((Key)ws.Target).SetComposeString(val);
}
catch (Exception e)
{
}
else
{
- efl_input_key_compose_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
+ efl_input_key_compose_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
}
}
- private static efl_input_key_compose_set_delegate efl_input_key_compose_set_static_delegate;
+ private static efl_input_key_compose_string_set_delegate efl_input_key_compose_string_set_static_delegate;
private delegate int efl_input_key_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
Efl.Input.Pointer.NativeMethods.efl_input_pointer_previous_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_pos);
Eina.Error.RaiseIfUnhandledException();
}
- /// <summary>ID of the tool (eg. pen) that triggered this event.</summary>
- /// <returns>Tool ID</returns>
- virtual public int GetTool() {
- var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_tool_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ /// <summary>TThe ID associated with this pointer.
+ /// In case there are multiple pointers (for example when multiple fingers are touching the screen) this number uniquely identifies each pointer, for as long as it is present. This is, when a finger is lifted its ID can be later reused by another finger touching the screen.</summary>
+ /// <returns>An ID uniquely identifying this pointer among the currently present pointers.</returns>
+ virtual public int GetTouchId() {
+ var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_touch_id_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
- /// <summary>ID of the tool (eg. pen) that triggered this event.</summary>
- /// <param name="id">Tool ID</param>
- virtual public void SetTool(int id) {
- Efl.Input.Pointer.NativeMethods.efl_input_pointer_tool_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),id);
+ /// <summary>TThe ID associated with this pointer.
+ /// In case there are multiple pointers (for example when multiple fingers are touching the screen) this number uniquely identifies each pointer, for as long as it is present. This is, when a finger is lifted its ID can be later reused by another finger touching the screen.</summary>
+ /// <param name="id">An ID uniquely identifying this pointer among the currently present pointers.</param>
+ virtual public void SetTouchId(int id) {
+ Efl.Input.Pointer.NativeMethods.efl_input_pointer_touch_id_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),id);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>The object where this event first originated, in case of propagation or repetition of the event.</summary>
get { return GetPreviousPosition(); }
set { SetPreviousPosition(value); }
}
- /// <summary>ID of the tool (eg. pen) that triggered this event.</summary>
- /// <value>Tool ID</value>
- public int Tool {
- get { return GetTool(); }
- set { SetTool(value); }
+ /// <summary>TThe ID associated with this pointer.
+ /// In case there are multiple pointers (for example when multiple fingers are touching the screen) this number uniquely identifies each pointer, for as long as it is present. This is, when a finger is lifted its ID can be later reused by another finger touching the screen.</summary>
+ /// <value>An ID uniquely identifying this pointer among the currently present pointers.</value>
+ public int TouchId {
+ get { return GetTouchId(); }
+ set { SetTouchId(value); }
}
/// <summary>The object where this event first originated, in case of propagation or repetition of the event.</summary>
/// <value>Source object: <see cref="Efl.Gfx.IEntity"/></value>
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_previous_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_previous_position_set_static_delegate) });
}
- if (efl_input_pointer_tool_get_static_delegate == null)
+ if (efl_input_pointer_touch_id_get_static_delegate == null)
{
- efl_input_pointer_tool_get_static_delegate = new efl_input_pointer_tool_get_delegate(tool_get);
+ efl_input_pointer_touch_id_get_static_delegate = new efl_input_pointer_touch_id_get_delegate(touch_id_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetTool") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetTouchId") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_tool_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_tool_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_touch_id_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_touch_id_get_static_delegate) });
}
- if (efl_input_pointer_tool_set_static_delegate == null)
+ if (efl_input_pointer_touch_id_set_static_delegate == null)
{
- efl_input_pointer_tool_set_static_delegate = new efl_input_pointer_tool_set_delegate(tool_set);
+ efl_input_pointer_touch_id_set_static_delegate = new efl_input_pointer_touch_id_set_delegate(touch_id_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetTool") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetTouchId") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_tool_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_tool_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_touch_id_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_touch_id_set_static_delegate) });
}
if (efl_input_pointer_source_get_static_delegate == null)
private static efl_input_pointer_previous_position_set_delegate efl_input_pointer_previous_position_set_static_delegate;
- private delegate int efl_input_pointer_tool_get_delegate(System.IntPtr obj, System.IntPtr pd);
+ private delegate int efl_input_pointer_touch_id_get_delegate(System.IntPtr obj, System.IntPtr pd);
- public delegate int efl_input_pointer_tool_get_api_delegate(System.IntPtr obj);
+ public delegate int efl_input_pointer_touch_id_get_api_delegate(System.IntPtr obj);
- public static Efl.Eo.FunctionWrapper<efl_input_pointer_tool_get_api_delegate> efl_input_pointer_tool_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_tool_get_api_delegate>(Module, "efl_input_pointer_tool_get");
+ public static Efl.Eo.FunctionWrapper<efl_input_pointer_touch_id_get_api_delegate> efl_input_pointer_touch_id_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_touch_id_get_api_delegate>(Module, "efl_input_pointer_touch_id_get");
- private static int tool_get(System.IntPtr obj, System.IntPtr pd)
+ private static int touch_id_get(System.IntPtr obj, System.IntPtr pd)
{
- Eina.Log.Debug("function efl_input_pointer_tool_get was called");
+ Eina.Log.Debug("function efl_input_pointer_touch_id_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
int _ret_var = default(int);
try
{
- _ret_var = ((Pointer)ws.Target).GetTool();
+ _ret_var = ((Pointer)ws.Target).GetTouchId();
}
catch (Exception e)
{
}
else
{
- return efl_input_pointer_tool_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ return efl_input_pointer_touch_id_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
- private static efl_input_pointer_tool_get_delegate efl_input_pointer_tool_get_static_delegate;
+ private static efl_input_pointer_touch_id_get_delegate efl_input_pointer_touch_id_get_static_delegate;
- private delegate void efl_input_pointer_tool_set_delegate(System.IntPtr obj, System.IntPtr pd, int id);
+ private delegate void efl_input_pointer_touch_id_set_delegate(System.IntPtr obj, System.IntPtr pd, int id);
- public delegate void efl_input_pointer_tool_set_api_delegate(System.IntPtr obj, int id);
+ public delegate void efl_input_pointer_touch_id_set_api_delegate(System.IntPtr obj, int id);
- public static Efl.Eo.FunctionWrapper<efl_input_pointer_tool_set_api_delegate> efl_input_pointer_tool_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_tool_set_api_delegate>(Module, "efl_input_pointer_tool_set");
+ public static Efl.Eo.FunctionWrapper<efl_input_pointer_touch_id_set_api_delegate> efl_input_pointer_touch_id_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_touch_id_set_api_delegate>(Module, "efl_input_pointer_touch_id_set");
- private static void tool_set(System.IntPtr obj, System.IntPtr pd, int id)
+ private static void touch_id_set(System.IntPtr obj, System.IntPtr pd, int id)
{
- Eina.Log.Debug("function efl_input_pointer_tool_set was called");
+ Eina.Log.Debug("function efl_input_pointer_touch_id_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((Pointer)ws.Target).SetTool(id);
+ ((Pointer)ws.Target).SetTouchId(id);
}
catch (Exception e)
{
}
else
{
- efl_input_pointer_tool_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id);
+ efl_input_pointer_touch_id_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id);
}
}
- private static efl_input_pointer_tool_set_delegate efl_input_pointer_tool_set_static_delegate;
+ private static efl_input_pointer_touch_id_set_delegate efl_input_pointer_touch_id_set_static_delegate;
[return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
private delegate Efl.Object efl_input_pointer_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
Button = 2,
/// <summary>32-bit bit mask (unsigned int). Prefer the method <c>buttons_pressed</c> to read this value. Default: 0.</summary>
ButtonsPressed = 3,
-/// <summary>ID of the finger or tool (eg. pen) that triggered this event. Prefer the property <c>tool</c> to read this value. Default: 0.</summary>
-Tool = 4,
+/// <summary>ID of the finger or tool (eg. pen) that triggered this event. Prefer the property <c>touch_id</c> to read this value. Default: 0.</summary>
+TouchId = 4,
/// <summary>Absolute X position where this event occurred, in pixels. Relative to the window. Default: last known position. This value may be smoothed out or even extrapolated by EFL.</summary>
X = 5,
/// <summary>Absolute Y position where this event occurred, in pixels. Relative to the window. Default: last known position. This value may be smoothed out or even extrapolated by EFL.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_interpolator_interface_get();
/// <summary>Initializes a new instance of the <see cref="IInterpolator"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
+++ /dev/null
-#pragma warning disable CS1591
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.ComponentModel;
-namespace Efl {
-
-namespace Io {
-
-/// <summary>Generic In-memory buffer of data to be used as I/O.
-/// This class offers both input and output, which can be used at the same time since <see cref="Efl.Io.IReader.Read"/> and <see cref="Efl.Io.IWriter.Write"/> use different offsets/position internally.
-///
-/// One can get temporary direct access to internal buffer with <see cref="Efl.Io.Buffer.GetSlice"/> or steal the buffer with <see cref="Efl.Io.Buffer.BinbufSteal"/>.
-///
-/// A fixed sized buffer can be implemented by setting <see cref="Efl.Io.Buffer.Limit"/> followed by <see cref="Efl.Io.Buffer.Preallocate"/></summary>
-[Efl.Io.Buffer.NativeMethods]
-public class Buffer : Efl.Object, Efl.Io.ICloser, Efl.Io.IPositioner, Efl.Io.IReader, Efl.Io.ISizer, Efl.Io.IWriter
-{
- ///<summary>Pointer to the native class description.</summary>
- public override System.IntPtr NativeClass
- {
- get
- {
- if (((object)this).GetType() == typeof(Buffer))
- {
- return GetEflClassStatic();
- }
- else
- {
- return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
- }
- }
- }
-
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
- efl_io_buffer_class_get();
- /// <summary>Initializes a new instance of the <see cref="Buffer"/> class.</summary>
- /// <param name="parent">Parent instance.</param>
- public Buffer(Efl.Object parent= null
- ) : base(efl_io_buffer_class_get(), typeof(Buffer), parent)
- {
- FinishInstantiation();
- }
-
- /// <summary>Initializes a new instance of the <see cref="Buffer"/> class.
- /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
- /// <param name="raw">The native pointer to be wrapped.</param>
- protected Buffer(System.IntPtr raw) : base(raw)
- {
- }
-
- /// <summary>Initializes a new instance of the <see cref="Buffer"/> class.
- /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
- /// <param name="baseKlass">The pointer to the base native Eo class.</param>
- /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
- /// <param name="parent">The Efl.Object parent of this instance.</param>
- protected Buffer(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
- {
- }
-
- /// <summary>Notifies <see cref="Efl.Io.Buffer.PositionRead"/> changed</summary>
- public event EventHandler PositionReadChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event PositionReadChangedEvt.</summary>
- public void OnPositionReadChangedEvt(EventArgs e)
- {
- var key = "_EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies <see cref="Efl.Io.Buffer.PositionWrite"/> changed</summary>
- public event EventHandler PositionWriteChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event PositionWriteChangedEvt.</summary>
- public void OnPositionWriteChangedEvt(EventArgs e)
- {
- var key = "_EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies the internal buffer was reallocated, thus whatever was returned by <see cref="Efl.Io.Buffer.GetSlice"/> becomes invalid</summary>
- public event EventHandler ReallocatedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_BUFFER_EVENT_REALLOCATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_BUFFER_EVENT_REALLOCATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event ReallocatedEvt.</summary>
- public void OnReallocatedEvt(EventArgs e)
- {
- var key = "_EFL_IO_BUFFER_EVENT_REALLOCATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies closed, when property is marked as true
- /// (Since EFL 1.22)</summary>
- public event EventHandler ClosedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event ClosedEvt.</summary>
- public void OnClosedEvt(EventArgs e)
- {
- var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies position changed</summary>
- public event EventHandler PositionChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_POSITIONER_EVENT_POSITION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_POSITIONER_EVENT_POSITION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event PositionChangedEvt.</summary>
- public void OnPositionChangedEvt(EventArgs e)
- {
- var key = "_EFL_IO_POSITIONER_EVENT_POSITION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies can_read property changed.
- /// If <see cref="Efl.Io.IReader.CanRead"/> is <c>true</c> there is data to <see cref="Efl.Io.IReader.Read"/> without blocking/error. If <see cref="Efl.Io.IReader.CanRead"/> is <c>false</c>, <see cref="Efl.Io.IReader.Read"/> would either block or fail.
- ///
- /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IReader.Read"/>, thus before it returns.
- /// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Io.IReaderCanReadChangedEvt_Args> CanReadChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Io.IReaderCanReadChangedEvt_Args args = new Efl.Io.IReaderCanReadChangedEvt_Args();
- args.arg = Marshal.ReadByte(evt.Info) != 0;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event CanReadChangedEvt.</summary>
- public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
- {
- var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
- try
- {
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Notifies end of stream, when property is marked as true.
- /// If this is used alongside with an <see cref="Efl.Io.ICloser"/>, then it should be emitted before that call.
- ///
- /// It should be emitted only once for an object unless it implements <see cref="Efl.Io.IPositioner.Seek"/>.
- ///
- /// The property <see cref="Efl.Io.IReader.CanRead"/> should change to <c>false</c> before this event is dispatched.
- /// (Since EFL 1.22)</summary>
- public event EventHandler EosEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_READER_EVENT_EOS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_READER_EVENT_EOS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event EosEvt.</summary>
- public void OnEosEvt(EventArgs e)
- {
- var key = "_EFL_IO_READER_EVENT_EOS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies size changed</summary>
- public event EventHandler SizeChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event SizeChangedEvt.</summary>
- public void OnSizeChangedEvt(EventArgs e)
- {
- var key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies can_write property changed.
- /// If <see cref="Efl.Io.IWriter.CanWrite"/> is <c>true</c> there is data to <see cref="Efl.Io.IWriter.Write"/> without blocking/error. If <see cref="Efl.Io.IWriter.CanWrite"/> is <c>false</c>, <see cref="Efl.Io.IWriter.Write"/> would either block or fail.
- ///
- /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IWriter.Write"/>, thus before it returns.
- /// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Io.IWriterCanWriteChangedEvt_Args> CanWriteChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Io.IWriterCanWriteChangedEvt_Args args = new Efl.Io.IWriterCanWriteChangedEvt_Args();
- args.arg = Marshal.ReadByte(evt.Info) != 0;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event CanWriteChangedEvt.</summary>
- public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
- {
- var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
- try
- {
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Limit how big the buffer can grow.
- /// This affects both <see cref="Efl.Io.Buffer.Preallocate"/> and how buffer grows when <see cref="Efl.Io.IWriter.Write"/> is called.
- ///
- /// If you want a buffer of an exact size always set the limit before any further calls that can expand it.</summary>
- /// <returns>Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</returns>
- virtual public uint GetLimit() {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_limit_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Constructor-only property to set buffer limit. 0 is unlimited</summary>
- /// <param name="size">Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</param>
- virtual public void SetLimit(uint size) {
- Efl.Io.Buffer.NativeMethods.efl_io_buffer_limit_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>The position used by <see cref="Efl.Io.IReader.Read"/>.
- /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionWrite"/>.
- ///
- /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
- /// <returns>Position in buffer</returns>
- virtual public ulong GetPositionRead() {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_read_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>The position used by <see cref="Efl.Io.IReader.Read"/>.
- /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionWrite"/>.
- ///
- /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
- /// <param name="position">Position in buffer</param>
- /// <returns><c>true</c> if setting the position succeeded, <c>false</c> otherwise</returns>
- virtual public bool SetPositionRead(ulong position) {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_read_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),position);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>The position used by <see cref="Efl.Io.IWriter.Write"/>.
- /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionRead"/>.
- ///
- /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
- /// <returns>Position in buffer</returns>
- virtual public ulong GetPositionWrite() {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_write_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>The position used by <see cref="Efl.Io.IWriter.Write"/>.
- /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionRead"/>.
- ///
- /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
- /// <param name="position">Position in buffer</param>
- /// <returns><c>true</c> if setting the position succeeded, <c>false</c> otherwise</returns>
- virtual public bool SetPositionWrite(ulong position) {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_write_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),position);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Get a temporary access to buffer's internal memory.
- /// The memory pointed by slice may be changed by other methods of this class. The event "reallocated" will be called in those situations.</summary>
- /// <returns>Slice of the current buffer, may be invalidated if <see cref="Efl.Io.IWriter.Write"/>, <see cref="Efl.Io.ICloser.Close"/> or <see cref="Efl.Io.ISizer.Resize"/> are called. It is the full slice, not a partial one starting at current position.</returns>
- virtual public Eina.Slice GetSlice() {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_slice_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Immediately pre-allocate a buffer of at least a given size.</summary>
- /// <param name="size">Amount of bytes to pre-allocate.</param>
- virtual public void Preallocate(uint size) {
- Efl.Io.Buffer.NativeMethods.efl_io_buffer_preallocate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Adopt a read-only slice as buffer's backing store.
- /// The slice memory will not be copied and must remain alive during the buffer's lifetime. Usually this is guaranteed by some global static-const memory or some parent object and this buffer being a view of that -- be aware of parent memory remaining alive, such as "slice,changed" events.</summary>
- /// <param name="slice">Slice to adopt as read-only</param>
- virtual public void AdoptReadonly(Eina.Slice slice) {
- Efl.Io.Buffer.NativeMethods.efl_io_buffer_adopt_readonly_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),slice);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Adopt a read-write slice as buffer's backing store.
- /// The slice memory will not be copied and must remain alive during the buffer's lifetime. Usually this is guaranteed by some global static memory or some parent object and this buffer being a view of that -- be aware of parent memory remaining alive, such as "slice,changed" events.
- ///
- /// The memory will be disposed using free() and reallocated using realloc().</summary>
- /// <param name="slice">Slice to adopt as read-write</param>
- virtual public void AdoptReadwrite(Eina.RwSlice slice) {
- Efl.Io.Buffer.NativeMethods.efl_io_buffer_adopt_readwrite_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),slice);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Steals the internal buffer memory and returns it as a binbuf.
- /// The returned memory must be freed with eina_binbuf_free().
- ///
- /// On failure, for example a read-only backing store was adopted with <see cref="Efl.Io.Buffer.AdoptReadonly"/>, NULL is returned.</summary>
- /// <returns>Binbuf</returns>
- virtual public Eina.Binbuf BinbufSteal() {
- var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_binbuf_steal_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- var _binbuf_ret = new Eina.Binbuf(_ret_var, true);
- return _binbuf_ret;
- }
- /// <summary>If true will notify object was closed.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if closed, <c>false</c> otherwise</returns>
- virtual public bool GetClosed() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_closed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If true will automatically close resources on exec() calls.
- /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if close on exec(), <c>false</c> otherwise</returns>
- virtual public bool GetCloseOnExec() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_exec_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c>, will close on exec() call.
- /// (Since EFL 1.22)</summary>
- /// <param name="close_on_exec"><c>true</c> if close on exec(), <c>false</c> otherwise</param>
- /// <returns><c>true</c> if could set, <c>false</c> if not supported or failed.</returns>
- virtual public bool SetCloseOnExec(bool close_on_exec) {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_exec_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),close_on_exec);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If true will automatically close() on object invalidate.
- /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if close on invalidate, <c>false</c> otherwise</returns>
- virtual public bool GetCloseOnInvalidate() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If true will automatically close() on object invalidate.
- /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
- /// (Since EFL 1.22)</summary>
- /// <param name="close_on_invalidate"><c>true</c> if close on invalidate, <c>false</c> otherwise</param>
- virtual public void SetCloseOnInvalidate(bool close_on_invalidate) {
- Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),close_on_invalidate);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Closes the Input/Output object.
- /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is to be defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
- ///
- /// You can understand this method as close(2) libc function.
- /// (Since EFL 1.22)</summary>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Close() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Position property</summary>
- /// <returns>Position in file or buffer</returns>
- virtual public ulong GetPosition() {
- var _ret_var = Efl.Io.IPositionerConcrete.NativeMethods.efl_io_positioner_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Try to set position object, relative to start of file. See <see cref="Efl.Io.IPositioner.Seek"/></summary>
- /// <param name="position">Position in file or buffer</param>
- /// <returns><c>true</c> if could reposition, <c>false</c> if errors.</returns>
- virtual public bool SetPosition(ulong position) {
- var _ret_var = Efl.Io.IPositionerConcrete.NativeMethods.efl_io_positioner_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),position);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Seek in data</summary>
- /// <param name="offset">Offset in byte relative to whence</param>
- /// <param name="whence">Whence</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Seek(long offset, Efl.Io.PositionerWhence whence) {
- var _ret_var = Efl.Io.IPositionerConcrete.NativeMethods.efl_io_positioner_seek_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),offset, whence);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</returns>
- virtual public bool GetCanRead() {
- var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_can_read_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <param name="can_read"><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</param>
- virtual public void SetCanRead(bool can_read) {
- Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_can_read_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),can_read);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>If <c>true</c> will notify end of stream.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if end of stream, <c>false</c> otherwise</returns>
- virtual public bool GetEos() {
- var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_eos_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify end of stream.
- /// (Since EFL 1.22)</summary>
- /// <param name="is_eos"><c>true</c> if end of stream, <c>false</c> otherwise</param>
- virtual public void SetEos(bool is_eos) {
- Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_eos_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),is_eos);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Reads data into a pre-allocated buffer.
- /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is to be defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
- ///
- /// You can understand this method as read(2) libc function.
- /// (Since EFL 1.22)</summary>
- /// <param name="rw_slice">Provides a pre-allocated memory to be filled up to rw_slice.len. It will be populated and the length will be set to the actually used amount of bytes, which can be smaller than the request.</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Read(ref Eina.RwSlice rw_slice) {
- var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_read_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ref rw_slice);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Size property</summary>
- /// <returns>Object size</returns>
- virtual public ulong GetSize() {
- var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Try to resize the object, check with get if the value was accepted or not.</summary>
- /// <param name="size">Object size</param>
- /// <returns><c>true</c> if could resize, <c>false</c> if errors.</returns>
- virtual public bool SetSize(ulong size) {
- var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Resize object</summary>
- /// <param name="size">Object size</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Resize(ulong size) {
- var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_resize_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</returns>
- virtual public bool GetCanWrite() {
- var _ret_var = Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_can_write_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <param name="can_write"><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</param>
- virtual public void SetCanWrite(bool can_write) {
- Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_can_write_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),can_write);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Writes data from a pre-populated buffer.
- /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
- ///
- /// You can understand this method as write(2) libc function.
- /// (Since EFL 1.22)</summary>
- /// <param name="slice">Provides a pre-populated memory to be used up to slice.len. The returned slice will be adapted as length will be set to the actually used amount of bytes, which can be smaller than the request.</param>
- /// <param name="remaining">Convenience to output the remaining parts of slice that was not written. If the full slice was written, this will be a slice of zero-length.</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Write(ref Eina.Slice slice, ref Eina.Slice remaining) {
- var _ret_var = Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_write_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ref slice, ref remaining);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Limit how big the buffer can grow.
- /// This affects both <see cref="Efl.Io.Buffer.Preallocate"/> and how buffer grows when <see cref="Efl.Io.IWriter.Write"/> is called.
- ///
- /// If you want a buffer of an exact size always set the limit before any further calls that can expand it.</summary>
- /// <value>Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</value>
- public uint Limit {
- get { return GetLimit(); }
- set { SetLimit(value); }
- }
- /// <summary>The position used by <see cref="Efl.Io.IReader.Read"/>.
- /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionWrite"/>.
- ///
- /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
- /// <value>Position in buffer</value>
- public ulong PositionRead {
- get { return GetPositionRead(); }
- set { SetPositionRead(value); }
- }
- /// <summary>The position used by <see cref="Efl.Io.IWriter.Write"/>.
- /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionRead"/>.
- ///
- /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
- /// <value>Position in buffer</value>
- public ulong PositionWrite {
- get { return GetPositionWrite(); }
- set { SetPositionWrite(value); }
- }
- /// <summary>Get a temporary access to buffer's internal memory.
- /// The memory pointed by slice may be changed by other methods of this class. The event "reallocated" will be called in those situations.</summary>
- /// <value>Slice of the current buffer, may be invalidated if <see cref="Efl.Io.IWriter.Write"/>, <see cref="Efl.Io.ICloser.Close"/> or <see cref="Efl.Io.ISizer.Resize"/> are called. It is the full slice, not a partial one starting at current position.</value>
- public Eina.Slice Slice {
- get { return GetSlice(); }
- }
- /// <summary>If true will notify object was closed.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if closed, <c>false</c> otherwise</value>
- public bool Closed {
- get { return GetClosed(); }
- }
- /// <summary>If true will automatically close resources on exec() calls.
- /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if close on exec(), <c>false</c> otherwise</value>
- public bool CloseOnExec {
- get { return GetCloseOnExec(); }
- set { SetCloseOnExec(value); }
- }
- /// <summary>If true will automatically close() on object invalidate.
- /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if close on invalidate, <c>false</c> otherwise</value>
- public bool CloseOnInvalidate {
- get { return GetCloseOnInvalidate(); }
- set { SetCloseOnInvalidate(value); }
- }
- /// <summary>Position property</summary>
- /// <value>Position in file or buffer</value>
- public ulong Position {
- get { return GetPosition(); }
- set { SetPosition(value); }
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</value>
- public bool CanRead {
- get { return GetCanRead(); }
- set { SetCanRead(value); }
- }
- /// <summary>If <c>true</c> will notify end of stream.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if end of stream, <c>false</c> otherwise</value>
- public bool Eos {
- get { return GetEos(); }
- set { SetEos(value); }
- }
- /// <summary>Size property</summary>
- /// <value>Object size</value>
- public ulong Size {
- get { return GetSize(); }
- set { SetSize(value); }
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</value>
- public bool CanWrite {
- get { return GetCanWrite(); }
- set { SetCanWrite(value); }
- }
- private static IntPtr GetEflClassStatic()
- {
- return Efl.Io.Buffer.efl_io_buffer_class_get();
- }
- /// <summary>Wrapper for native methods and virtual method delegates.
- /// For internal use by generated code only.</summary>
- public new class NativeMethods : Efl.Object.NativeMethods
- {
- private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Efl);
- /// <summary>Gets the list of Eo operations to override.</summary>
- /// <returns>The list of Eo operations to be overload.</returns>
- public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
- {
- var descs = new System.Collections.Generic.List<Efl_Op_Description>();
- var methods = Efl.Eo.Globals.GetUserMethods(type);
-
- if (efl_io_buffer_limit_get_static_delegate == null)
- {
- efl_io_buffer_limit_get_static_delegate = new efl_io_buffer_limit_get_delegate(limit_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetLimit") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_limit_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_limit_get_static_delegate) });
- }
-
- if (efl_io_buffer_limit_set_static_delegate == null)
- {
- efl_io_buffer_limit_set_static_delegate = new efl_io_buffer_limit_set_delegate(limit_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetLimit") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_limit_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_limit_set_static_delegate) });
- }
-
- if (efl_io_buffer_position_read_get_static_delegate == null)
- {
- efl_io_buffer_position_read_get_static_delegate = new efl_io_buffer_position_read_get_delegate(position_read_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetPositionRead") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_read_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_read_get_static_delegate) });
- }
-
- if (efl_io_buffer_position_read_set_static_delegate == null)
- {
- efl_io_buffer_position_read_set_static_delegate = new efl_io_buffer_position_read_set_delegate(position_read_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetPositionRead") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_read_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_read_set_static_delegate) });
- }
-
- if (efl_io_buffer_position_write_get_static_delegate == null)
- {
- efl_io_buffer_position_write_get_static_delegate = new efl_io_buffer_position_write_get_delegate(position_write_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetPositionWrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_write_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_write_get_static_delegate) });
- }
-
- if (efl_io_buffer_position_write_set_static_delegate == null)
- {
- efl_io_buffer_position_write_set_static_delegate = new efl_io_buffer_position_write_set_delegate(position_write_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetPositionWrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_write_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_write_set_static_delegate) });
- }
-
- if (efl_io_buffer_slice_get_static_delegate == null)
- {
- efl_io_buffer_slice_get_static_delegate = new efl_io_buffer_slice_get_delegate(slice_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetSlice") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_slice_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_slice_get_static_delegate) });
- }
-
- if (efl_io_buffer_preallocate_static_delegate == null)
- {
- efl_io_buffer_preallocate_static_delegate = new efl_io_buffer_preallocate_delegate(preallocate);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Preallocate") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_preallocate"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_preallocate_static_delegate) });
- }
-
- if (efl_io_buffer_adopt_readonly_static_delegate == null)
- {
- efl_io_buffer_adopt_readonly_static_delegate = new efl_io_buffer_adopt_readonly_delegate(adopt_readonly);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "AdoptReadonly") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_adopt_readonly"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_adopt_readonly_static_delegate) });
- }
-
- if (efl_io_buffer_adopt_readwrite_static_delegate == null)
- {
- efl_io_buffer_adopt_readwrite_static_delegate = new efl_io_buffer_adopt_readwrite_delegate(adopt_readwrite);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "AdoptReadwrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_adopt_readwrite"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_adopt_readwrite_static_delegate) });
- }
-
- if (efl_io_buffer_binbuf_steal_static_delegate == null)
- {
- efl_io_buffer_binbuf_steal_static_delegate = new efl_io_buffer_binbuf_steal_delegate(binbuf_steal);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "BinbufSteal") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_binbuf_steal"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_binbuf_steal_static_delegate) });
- }
-
- if (efl_io_closer_closed_get_static_delegate == null)
- {
- efl_io_closer_closed_get_static_delegate = new efl_io_closer_closed_get_delegate(closed_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetClosed") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_closed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_closed_get_static_delegate) });
- }
-
- if (efl_io_closer_close_on_exec_get_static_delegate == null)
- {
- efl_io_closer_close_on_exec_get_static_delegate = new efl_io_closer_close_on_exec_get_delegate(close_on_exec_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCloseOnExec") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_exec_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_exec_get_static_delegate) });
- }
-
- if (efl_io_closer_close_on_exec_set_static_delegate == null)
- {
- efl_io_closer_close_on_exec_set_static_delegate = new efl_io_closer_close_on_exec_set_delegate(close_on_exec_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCloseOnExec") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_exec_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_exec_set_static_delegate) });
- }
-
- if (efl_io_closer_close_on_invalidate_get_static_delegate == null)
- {
- efl_io_closer_close_on_invalidate_get_static_delegate = new efl_io_closer_close_on_invalidate_get_delegate(close_on_invalidate_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCloseOnInvalidate") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_invalidate_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_invalidate_get_static_delegate) });
- }
-
- if (efl_io_closer_close_on_invalidate_set_static_delegate == null)
- {
- efl_io_closer_close_on_invalidate_set_static_delegate = new efl_io_closer_close_on_invalidate_set_delegate(close_on_invalidate_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCloseOnInvalidate") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_invalidate_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_invalidate_set_static_delegate) });
- }
-
- if (efl_io_closer_close_static_delegate == null)
- {
- efl_io_closer_close_static_delegate = new efl_io_closer_close_delegate(close);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Close") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_static_delegate) });
- }
-
- if (efl_io_positioner_position_get_static_delegate == null)
- {
- efl_io_positioner_position_get_static_delegate = new efl_io_positioner_position_get_delegate(position_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetPosition") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_positioner_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_positioner_position_get_static_delegate) });
- }
-
- if (efl_io_positioner_position_set_static_delegate == null)
- {
- efl_io_positioner_position_set_static_delegate = new efl_io_positioner_position_set_delegate(position_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetPosition") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_positioner_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_positioner_position_set_static_delegate) });
- }
-
- if (efl_io_positioner_seek_static_delegate == null)
- {
- efl_io_positioner_seek_static_delegate = new efl_io_positioner_seek_delegate(seek);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Seek") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_positioner_seek"), func = Marshal.GetFunctionPointerForDelegate(efl_io_positioner_seek_static_delegate) });
- }
-
- if (efl_io_reader_can_read_get_static_delegate == null)
- {
- efl_io_reader_can_read_get_static_delegate = new efl_io_reader_can_read_get_delegate(can_read_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCanRead") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_can_read_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_can_read_get_static_delegate) });
- }
-
- if (efl_io_reader_can_read_set_static_delegate == null)
- {
- efl_io_reader_can_read_set_static_delegate = new efl_io_reader_can_read_set_delegate(can_read_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCanRead") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_can_read_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_can_read_set_static_delegate) });
- }
-
- if (efl_io_reader_eos_get_static_delegate == null)
- {
- efl_io_reader_eos_get_static_delegate = new efl_io_reader_eos_get_delegate(eos_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetEos") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_eos_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_eos_get_static_delegate) });
- }
-
- if (efl_io_reader_eos_set_static_delegate == null)
- {
- efl_io_reader_eos_set_static_delegate = new efl_io_reader_eos_set_delegate(eos_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetEos") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_eos_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_eos_set_static_delegate) });
- }
-
- if (efl_io_reader_read_static_delegate == null)
- {
- efl_io_reader_read_static_delegate = new efl_io_reader_read_delegate(read);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Read") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_read"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_read_static_delegate) });
- }
-
- if (efl_io_sizer_size_get_static_delegate == null)
- {
- efl_io_sizer_size_get_static_delegate = new efl_io_sizer_size_get_delegate(size_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetSize") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_size_get_static_delegate) });
- }
-
- if (efl_io_sizer_size_set_static_delegate == null)
- {
- efl_io_sizer_size_set_static_delegate = new efl_io_sizer_size_set_delegate(size_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetSize") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_size_set_static_delegate) });
- }
-
- if (efl_io_sizer_resize_static_delegate == null)
- {
- efl_io_sizer_resize_static_delegate = new efl_io_sizer_resize_delegate(resize);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Resize") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_resize"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_resize_static_delegate) });
- }
-
- if (efl_io_writer_can_write_get_static_delegate == null)
- {
- efl_io_writer_can_write_get_static_delegate = new efl_io_writer_can_write_get_delegate(can_write_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCanWrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_can_write_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_can_write_get_static_delegate) });
- }
-
- if (efl_io_writer_can_write_set_static_delegate == null)
- {
- efl_io_writer_can_write_set_static_delegate = new efl_io_writer_can_write_set_delegate(can_write_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCanWrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_can_write_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_can_write_set_static_delegate) });
- }
-
- if (efl_io_writer_write_static_delegate == null)
- {
- efl_io_writer_write_static_delegate = new efl_io_writer_write_delegate(write);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Write") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_write"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_write_static_delegate) });
- }
-
- descs.AddRange(base.GetEoOps(type));
- return descs;
- }
- /// <summary>Returns the Eo class for the native methods of this class.</summary>
- /// <returns>The native class pointer.</returns>
- public override IntPtr GetEflClass()
- {
- return Efl.Io.Buffer.efl_io_buffer_class_get();
- }
-
- #pragma warning disable CA1707, CS1591, SA1300, SA1600
-
-
- private delegate uint efl_io_buffer_limit_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate uint efl_io_buffer_limit_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_limit_get_api_delegate> efl_io_buffer_limit_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_limit_get_api_delegate>(Module, "efl_io_buffer_limit_get");
-
- private static uint limit_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_buffer_limit_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- uint _ret_var = default(uint);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetLimit();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_buffer_limit_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_buffer_limit_get_delegate efl_io_buffer_limit_get_static_delegate;
-
-
- private delegate void efl_io_buffer_limit_set_delegate(System.IntPtr obj, System.IntPtr pd, uint size);
-
-
- public delegate void efl_io_buffer_limit_set_api_delegate(System.IntPtr obj, uint size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_limit_set_api_delegate> efl_io_buffer_limit_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_limit_set_api_delegate>(Module, "efl_io_buffer_limit_set");
-
- private static void limit_set(System.IntPtr obj, System.IntPtr pd, uint size)
- {
- Eina.Log.Debug("function efl_io_buffer_limit_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).SetLimit(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_buffer_limit_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_buffer_limit_set_delegate efl_io_buffer_limit_set_static_delegate;
-
-
- private delegate ulong efl_io_buffer_position_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate ulong efl_io_buffer_position_read_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_get_api_delegate> efl_io_buffer_position_read_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_get_api_delegate>(Module, "efl_io_buffer_position_read_get");
-
- private static ulong position_read_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_buffer_position_read_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- ulong _ret_var = default(ulong);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetPositionRead();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_buffer_position_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_buffer_position_read_get_delegate efl_io_buffer_position_read_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_buffer_position_read_set_delegate(System.IntPtr obj, System.IntPtr pd, ulong position);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_buffer_position_read_set_api_delegate(System.IntPtr obj, ulong position);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_set_api_delegate> efl_io_buffer_position_read_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_set_api_delegate>(Module, "efl_io_buffer_position_read_set");
-
- private static bool position_read_set(System.IntPtr obj, System.IntPtr pd, ulong position)
- {
- Eina.Log.Debug("function efl_io_buffer_position_read_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).SetPositionRead(position);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_buffer_position_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
- }
- }
-
- private static efl_io_buffer_position_read_set_delegate efl_io_buffer_position_read_set_static_delegate;
-
-
- private delegate ulong efl_io_buffer_position_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate ulong efl_io_buffer_position_write_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_get_api_delegate> efl_io_buffer_position_write_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_get_api_delegate>(Module, "efl_io_buffer_position_write_get");
-
- private static ulong position_write_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_buffer_position_write_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- ulong _ret_var = default(ulong);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetPositionWrite();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_buffer_position_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_buffer_position_write_get_delegate efl_io_buffer_position_write_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_buffer_position_write_set_delegate(System.IntPtr obj, System.IntPtr pd, ulong position);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_buffer_position_write_set_api_delegate(System.IntPtr obj, ulong position);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_set_api_delegate> efl_io_buffer_position_write_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_set_api_delegate>(Module, "efl_io_buffer_position_write_set");
-
- private static bool position_write_set(System.IntPtr obj, System.IntPtr pd, ulong position)
- {
- Eina.Log.Debug("function efl_io_buffer_position_write_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).SetPositionWrite(position);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_buffer_position_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
- }
- }
-
- private static efl_io_buffer_position_write_set_delegate efl_io_buffer_position_write_set_static_delegate;
-
-
- private delegate Eina.Slice efl_io_buffer_slice_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate Eina.Slice efl_io_buffer_slice_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_slice_get_api_delegate> efl_io_buffer_slice_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_slice_get_api_delegate>(Module, "efl_io_buffer_slice_get");
-
- private static Eina.Slice slice_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_buffer_slice_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Slice _ret_var = default(Eina.Slice);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetSlice();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_buffer_slice_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_buffer_slice_get_delegate efl_io_buffer_slice_get_static_delegate;
-
-
- private delegate void efl_io_buffer_preallocate_delegate(System.IntPtr obj, System.IntPtr pd, uint size);
-
-
- public delegate void efl_io_buffer_preallocate_api_delegate(System.IntPtr obj, uint size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_preallocate_api_delegate> efl_io_buffer_preallocate_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_preallocate_api_delegate>(Module, "efl_io_buffer_preallocate");
-
- private static void preallocate(System.IntPtr obj, System.IntPtr pd, uint size)
- {
- Eina.Log.Debug("function efl_io_buffer_preallocate was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).Preallocate(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_buffer_preallocate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_buffer_preallocate_delegate efl_io_buffer_preallocate_static_delegate;
-
-
- private delegate void efl_io_buffer_adopt_readonly_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Slice slice);
-
-
- public delegate void efl_io_buffer_adopt_readonly_api_delegate(System.IntPtr obj, Eina.Slice slice);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readonly_api_delegate> efl_io_buffer_adopt_readonly_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readonly_api_delegate>(Module, "efl_io_buffer_adopt_readonly");
-
- private static void adopt_readonly(System.IntPtr obj, System.IntPtr pd, Eina.Slice slice)
- {
- Eina.Log.Debug("function efl_io_buffer_adopt_readonly was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).AdoptReadonly(slice);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_buffer_adopt_readonly_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice);
- }
- }
-
- private static efl_io_buffer_adopt_readonly_delegate efl_io_buffer_adopt_readonly_static_delegate;
-
-
- private delegate void efl_io_buffer_adopt_readwrite_delegate(System.IntPtr obj, System.IntPtr pd, Eina.RwSlice slice);
-
-
- public delegate void efl_io_buffer_adopt_readwrite_api_delegate(System.IntPtr obj, Eina.RwSlice slice);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readwrite_api_delegate> efl_io_buffer_adopt_readwrite_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readwrite_api_delegate>(Module, "efl_io_buffer_adopt_readwrite");
-
- private static void adopt_readwrite(System.IntPtr obj, System.IntPtr pd, Eina.RwSlice slice)
- {
- Eina.Log.Debug("function efl_io_buffer_adopt_readwrite was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).AdoptReadwrite(slice);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_buffer_adopt_readwrite_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice);
- }
- }
-
- private static efl_io_buffer_adopt_readwrite_delegate efl_io_buffer_adopt_readwrite_static_delegate;
-
-
- private delegate System.IntPtr efl_io_buffer_binbuf_steal_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate System.IntPtr efl_io_buffer_binbuf_steal_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_buffer_binbuf_steal_api_delegate> efl_io_buffer_binbuf_steal_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_binbuf_steal_api_delegate>(Module, "efl_io_buffer_binbuf_steal");
-
- private static System.IntPtr binbuf_steal(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_buffer_binbuf_steal was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Binbuf _ret_var = default(Eina.Binbuf);
- try
- {
- _ret_var = ((Buffer)ws.Target).BinbufSteal();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- _ret_var.Own = false; return _ret_var.Handle;
-
- }
- else
- {
- return efl_io_buffer_binbuf_steal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_buffer_binbuf_steal_delegate efl_io_buffer_binbuf_steal_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_closed_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_closed_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_closed_get_api_delegate> efl_io_closer_closed_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_closed_get_api_delegate>(Module, "efl_io_closer_closed_get");
-
- private static bool closed_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_closed_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetClosed();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_closed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_closed_get_delegate efl_io_closer_closed_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_close_on_exec_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_close_on_exec_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_get_api_delegate> efl_io_closer_close_on_exec_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_get_api_delegate>(Module, "efl_io_closer_close_on_exec_get");
-
- private static bool close_on_exec_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_exec_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetCloseOnExec();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_on_exec_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_close_on_exec_get_delegate efl_io_closer_close_on_exec_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_close_on_exec_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_close_on_exec_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_set_api_delegate> efl_io_closer_close_on_exec_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_set_api_delegate>(Module, "efl_io_closer_close_on_exec_set");
-
- private static bool close_on_exec_set(System.IntPtr obj, System.IntPtr pd, bool close_on_exec)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_exec_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).SetCloseOnExec(close_on_exec);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_on_exec_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), close_on_exec);
- }
- }
-
- private static efl_io_closer_close_on_exec_set_delegate efl_io_closer_close_on_exec_set_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_close_on_invalidate_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_close_on_invalidate_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_get_api_delegate> efl_io_closer_close_on_invalidate_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_get_api_delegate>(Module, "efl_io_closer_close_on_invalidate_get");
-
- private static bool close_on_invalidate_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_invalidate_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetCloseOnInvalidate();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_close_on_invalidate_get_delegate efl_io_closer_close_on_invalidate_get_static_delegate;
-
-
- private delegate void efl_io_closer_close_on_invalidate_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
-
-
- public delegate void efl_io_closer_close_on_invalidate_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_set_api_delegate> efl_io_closer_close_on_invalidate_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_set_api_delegate>(Module, "efl_io_closer_close_on_invalidate_set");
-
- private static void close_on_invalidate_set(System.IntPtr obj, System.IntPtr pd, bool close_on_invalidate)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_invalidate_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).SetCloseOnInvalidate(close_on_invalidate);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), close_on_invalidate);
- }
- }
-
- private static efl_io_closer_close_on_invalidate_set_delegate efl_io_closer_close_on_invalidate_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_closer_close_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate Eina.Error efl_io_closer_close_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_api_delegate> efl_io_closer_close_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_api_delegate>(Module, "efl_io_closer_close");
-
- private static Eina.Error close(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_close was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Buffer)ws.Target).Close();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_close_delegate efl_io_closer_close_static_delegate;
-
-
- private delegate ulong efl_io_positioner_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate ulong efl_io_positioner_position_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_positioner_position_get_api_delegate> efl_io_positioner_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_positioner_position_get_api_delegate>(Module, "efl_io_positioner_position_get");
-
- private static ulong position_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_positioner_position_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- ulong _ret_var = default(ulong);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetPosition();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_positioner_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_positioner_position_get_delegate efl_io_positioner_position_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_positioner_position_set_delegate(System.IntPtr obj, System.IntPtr pd, ulong position);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_positioner_position_set_api_delegate(System.IntPtr obj, ulong position);
-
- public static Efl.Eo.FunctionWrapper<efl_io_positioner_position_set_api_delegate> efl_io_positioner_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_positioner_position_set_api_delegate>(Module, "efl_io_positioner_position_set");
-
- private static bool position_set(System.IntPtr obj, System.IntPtr pd, ulong position)
- {
- Eina.Log.Debug("function efl_io_positioner_position_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).SetPosition(position);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_positioner_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
- }
- }
-
- private static efl_io_positioner_position_set_delegate efl_io_positioner_position_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_positioner_seek_delegate(System.IntPtr obj, System.IntPtr pd, long offset, Efl.Io.PositionerWhence whence);
-
-
- public delegate Eina.Error efl_io_positioner_seek_api_delegate(System.IntPtr obj, long offset, Efl.Io.PositionerWhence whence);
-
- public static Efl.Eo.FunctionWrapper<efl_io_positioner_seek_api_delegate> efl_io_positioner_seek_ptr = new Efl.Eo.FunctionWrapper<efl_io_positioner_seek_api_delegate>(Module, "efl_io_positioner_seek");
-
- private static Eina.Error seek(System.IntPtr obj, System.IntPtr pd, long offset, Efl.Io.PositionerWhence whence)
- {
- Eina.Log.Debug("function efl_io_positioner_seek was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Buffer)ws.Target).Seek(offset, whence);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_positioner_seek_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), offset, whence);
- }
- }
-
- private static efl_io_positioner_seek_delegate efl_io_positioner_seek_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_reader_can_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_reader_can_read_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_can_read_get_api_delegate> efl_io_reader_can_read_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_can_read_get_api_delegate>(Module, "efl_io_reader_can_read_get");
-
- private static bool can_read_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_reader_can_read_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetCanRead();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_reader_can_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_reader_can_read_get_delegate efl_io_reader_can_read_get_static_delegate;
-
-
- private delegate void efl_io_reader_can_read_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_read);
-
-
- public delegate void efl_io_reader_can_read_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_read);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_can_read_set_api_delegate> efl_io_reader_can_read_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_can_read_set_api_delegate>(Module, "efl_io_reader_can_read_set");
-
- private static void can_read_set(System.IntPtr obj, System.IntPtr pd, bool can_read)
- {
- Eina.Log.Debug("function efl_io_reader_can_read_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).SetCanRead(can_read);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_reader_can_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_read);
- }
- }
-
- private static efl_io_reader_can_read_set_delegate efl_io_reader_can_read_set_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_reader_eos_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_reader_eos_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_eos_get_api_delegate> efl_io_reader_eos_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_eos_get_api_delegate>(Module, "efl_io_reader_eos_get");
-
- private static bool eos_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_reader_eos_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetEos();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_reader_eos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_reader_eos_get_delegate efl_io_reader_eos_get_static_delegate;
-
-
- private delegate void efl_io_reader_eos_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool is_eos);
-
-
- public delegate void efl_io_reader_eos_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool is_eos);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_eos_set_api_delegate> efl_io_reader_eos_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_eos_set_api_delegate>(Module, "efl_io_reader_eos_set");
-
- private static void eos_set(System.IntPtr obj, System.IntPtr pd, bool is_eos)
- {
- Eina.Log.Debug("function efl_io_reader_eos_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).SetEos(is_eos);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_reader_eos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), is_eos);
- }
- }
-
- private static efl_io_reader_eos_set_delegate efl_io_reader_eos_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_reader_read_delegate(System.IntPtr obj, System.IntPtr pd, ref Eina.RwSlice rw_slice);
-
-
- public delegate Eina.Error efl_io_reader_read_api_delegate(System.IntPtr obj, ref Eina.RwSlice rw_slice);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_read_api_delegate> efl_io_reader_read_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_read_api_delegate>(Module, "efl_io_reader_read");
-
- private static Eina.Error read(System.IntPtr obj, System.IntPtr pd, ref Eina.RwSlice rw_slice)
- {
- Eina.Log.Debug("function efl_io_reader_read was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Buffer)ws.Target).Read(ref rw_slice);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_reader_read_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref rw_slice);
- }
- }
-
- private static efl_io_reader_read_delegate efl_io_reader_read_static_delegate;
-
-
- private delegate ulong efl_io_sizer_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate ulong efl_io_sizer_size_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_sizer_size_get_api_delegate> efl_io_sizer_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_size_get_api_delegate>(Module, "efl_io_sizer_size_get");
-
- private static ulong size_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_sizer_size_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- ulong _ret_var = default(ulong);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetSize();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_sizer_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_sizer_size_get_delegate efl_io_sizer_size_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_sizer_size_set_delegate(System.IntPtr obj, System.IntPtr pd, ulong size);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_sizer_size_set_api_delegate(System.IntPtr obj, ulong size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_sizer_size_set_api_delegate> efl_io_sizer_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_size_set_api_delegate>(Module, "efl_io_sizer_size_set");
-
- private static bool size_set(System.IntPtr obj, System.IntPtr pd, ulong size)
- {
- Eina.Log.Debug("function efl_io_sizer_size_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).SetSize(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_sizer_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_sizer_size_set_delegate efl_io_sizer_size_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_sizer_resize_delegate(System.IntPtr obj, System.IntPtr pd, ulong size);
-
-
- public delegate Eina.Error efl_io_sizer_resize_api_delegate(System.IntPtr obj, ulong size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_sizer_resize_api_delegate> efl_io_sizer_resize_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_resize_api_delegate>(Module, "efl_io_sizer_resize");
-
- private static Eina.Error resize(System.IntPtr obj, System.IntPtr pd, ulong size)
- {
- Eina.Log.Debug("function efl_io_sizer_resize was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Buffer)ws.Target).Resize(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_sizer_resize_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_sizer_resize_delegate efl_io_sizer_resize_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_writer_can_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_writer_can_write_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_writer_can_write_get_api_delegate> efl_io_writer_can_write_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_can_write_get_api_delegate>(Module, "efl_io_writer_can_write_get");
-
- private static bool can_write_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_writer_can_write_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Buffer)ws.Target).GetCanWrite();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_writer_can_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_writer_can_write_get_delegate efl_io_writer_can_write_get_static_delegate;
-
-
- private delegate void efl_io_writer_can_write_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_write);
-
-
- public delegate void efl_io_writer_can_write_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_write);
-
- public static Efl.Eo.FunctionWrapper<efl_io_writer_can_write_set_api_delegate> efl_io_writer_can_write_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_can_write_set_api_delegate>(Module, "efl_io_writer_can_write_set");
-
- private static void can_write_set(System.IntPtr obj, System.IntPtr pd, bool can_write)
- {
- Eina.Log.Debug("function efl_io_writer_can_write_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Buffer)ws.Target).SetCanWrite(can_write);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_writer_can_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_write);
- }
- }
-
- private static efl_io_writer_can_write_set_delegate efl_io_writer_can_write_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_writer_write_delegate(System.IntPtr obj, System.IntPtr pd, ref Eina.Slice slice, ref Eina.Slice remaining);
-
-
- public delegate Eina.Error efl_io_writer_write_api_delegate(System.IntPtr obj, ref Eina.Slice slice, ref Eina.Slice remaining);
-
- public static Efl.Eo.FunctionWrapper<efl_io_writer_write_api_delegate> efl_io_writer_write_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_write_api_delegate>(Module, "efl_io_writer_write");
-
- private static Eina.Error write(System.IntPtr obj, System.IntPtr pd, ref Eina.Slice slice, ref Eina.Slice remaining)
- {
- Eina.Log.Debug("function efl_io_writer_write was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- remaining = default(Eina.Slice); Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Buffer)ws.Target).Write(ref slice, ref remaining);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_writer_write_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref slice, ref remaining);
- }
- }
-
- private static efl_io_writer_write_delegate efl_io_writer_write_static_delegate;
-
- #pragma warning restore CA1707, CS1591, SA1300, SA1600
-
-}
-}
-}
-
-}
-
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_io_closer_interface_get();
/// <summary>Initializes a new instance of the <see cref="ICloser"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_io_positioner_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IPositioner"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
ulong _ret_var = default(ulong);
try
{
- _ret_var = ((IPositionerConcrete)ws.Target).GetPosition();
+ _ret_var = ((IPositioner)ws.Target).GetPosition();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IPositionerConcrete)ws.Target).SetPosition(position);
+ _ret_var = ((IPositioner)ws.Target).SetPosition(position);
}
catch (Exception e)
{
Eina.Error _ret_var = default(Eina.Error);
try
{
- _ret_var = ((IPositionerConcrete)ws.Target).Seek(offset, whence);
+ _ret_var = ((IPositioner)ws.Target).Seek(offset, whence);
}
catch (Exception e)
{
+++ /dev/null
-#pragma warning disable CS1591
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.ComponentModel;
-namespace Efl {
-
-namespace Io {
-
-/// <summary>Generic In-memory queue of data to be used as I/O.
-/// This class is to be used to receive temporary data using <see cref="Efl.Io.IWriter.Write"/> and hold it until someone calls <see cref="Efl.Io.IReader.Read"/> to consume it.
-///
-/// A fixed sized queue can be implemented by setting <see cref="Efl.Io.Queue.Limit"/> followed by <see cref="Efl.Io.Queue.Preallocate"/></summary>
-[Efl.Io.Queue.NativeMethods]
-public class Queue : Efl.Object, Efl.Io.ICloser, Efl.Io.IReader, Efl.Io.IWriter
-{
- ///<summary>Pointer to the native class description.</summary>
- public override System.IntPtr NativeClass
- {
- get
- {
- if (((object)this).GetType() == typeof(Queue))
- {
- return GetEflClassStatic();
- }
- else
- {
- return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
- }
- }
- }
-
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
- efl_io_queue_class_get();
- /// <summary>Initializes a new instance of the <see cref="Queue"/> class.</summary>
- /// <param name="parent">Parent instance.</param>
- public Queue(Efl.Object parent= null
- ) : base(efl_io_queue_class_get(), typeof(Queue), parent)
- {
- FinishInstantiation();
- }
-
- /// <summary>Initializes a new instance of the <see cref="Queue"/> class.
- /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
- /// <param name="raw">The native pointer to be wrapped.</param>
- protected Queue(System.IntPtr raw) : base(raw)
- {
- }
-
- /// <summary>Initializes a new instance of the <see cref="Queue"/> class.
- /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
- /// <param name="baseKlass">The pointer to the base native Eo class.</param>
- /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
- /// <param name="parent">The Efl.Object parent of this instance.</param>
- protected Queue(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
- {
- }
-
- /// <summary>The read-slice returned by <see cref="Efl.Io.Queue.GetSlice"/> may have changed.</summary>
- public event EventHandler SliceChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_QUEUE_EVENT_SLICE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_QUEUE_EVENT_SLICE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event SliceChangedEvt.</summary>
- public void OnSliceChangedEvt(EventArgs e)
- {
- var key = "_EFL_IO_QUEUE_EVENT_SLICE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies closed, when property is marked as true
- /// (Since EFL 1.22)</summary>
- public event EventHandler ClosedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event ClosedEvt.</summary>
- public void OnClosedEvt(EventArgs e)
- {
- var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies can_read property changed.
- /// If <see cref="Efl.Io.IReader.CanRead"/> is <c>true</c> there is data to <see cref="Efl.Io.IReader.Read"/> without blocking/error. If <see cref="Efl.Io.IReader.CanRead"/> is <c>false</c>, <see cref="Efl.Io.IReader.Read"/> would either block or fail.
- ///
- /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IReader.Read"/>, thus before it returns.
- /// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Io.IReaderCanReadChangedEvt_Args> CanReadChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Io.IReaderCanReadChangedEvt_Args args = new Efl.Io.IReaderCanReadChangedEvt_Args();
- args.arg = Marshal.ReadByte(evt.Info) != 0;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event CanReadChangedEvt.</summary>
- public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
- {
- var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
- try
- {
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Notifies end of stream, when property is marked as true.
- /// If this is used alongside with an <see cref="Efl.Io.ICloser"/>, then it should be emitted before that call.
- ///
- /// It should be emitted only once for an object unless it implements <see cref="Efl.Io.IPositioner.Seek"/>.
- ///
- /// The property <see cref="Efl.Io.IReader.CanRead"/> should change to <c>false</c> before this event is dispatched.
- /// (Since EFL 1.22)</summary>
- public event EventHandler EosEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_READER_EVENT_EOS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_READER_EVENT_EOS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event EosEvt.</summary>
- public void OnEosEvt(EventArgs e)
- {
- var key = "_EFL_IO_READER_EVENT_EOS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Notifies can_write property changed.
- /// If <see cref="Efl.Io.IWriter.CanWrite"/> is <c>true</c> there is data to <see cref="Efl.Io.IWriter.Write"/> without blocking/error. If <see cref="Efl.Io.IWriter.CanWrite"/> is <c>false</c>, <see cref="Efl.Io.IWriter.Write"/> would either block or fail.
- ///
- /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IWriter.Write"/>, thus before it returns.
- /// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Io.IWriterCanWriteChangedEvt_Args> CanWriteChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Io.IWriterCanWriteChangedEvt_Args args = new Efl.Io.IWriterCanWriteChangedEvt_Args();
- args.arg = Marshal.ReadByte(evt.Info) != 0;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event CanWriteChangedEvt.</summary>
- public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
- {
- var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
- try
- {
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Limit how big the buffer can grow.
- /// This affects both <see cref="Efl.Io.Queue.Preallocate"/> and how buffer grows when <see cref="Efl.Io.IWriter.Write"/> is called.
- ///
- /// If you want a buffer of an exact size, always set the limit before any further calls that can expand it.</summary>
- /// <returns>Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</returns>
- virtual public uint GetLimit() {
- var _ret_var = Efl.Io.Queue.NativeMethods.efl_io_queue_limit_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Constructor-only property to set buffer limit. 0 is unlimited</summary>
- /// <param name="size">Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</param>
- virtual public void SetLimit(uint size) {
- Efl.Io.Queue.NativeMethods.efl_io_queue_limit_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>How many bytes are available for read</summary>
- /// <returns>Bytes available to read</returns>
- virtual public uint GetUsage() {
- var _ret_var = Efl.Io.Queue.NativeMethods.efl_io_queue_usage_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Gain temporary access to queue's internal read memory.
- /// The memory pointed to by slice may be changed by other methods of this class. The event "slice,changed" will be called in those situations.</summary>
- /// <returns>Slice of the current buffer, may be invalidated if <see cref="Efl.Io.IWriter.Write"/>, <see cref="Efl.Io.ICloser.Close"/> or <see cref="Efl.Io.IReader.Read"/> are called. It is the full slice available for reading.</returns>
- virtual public Eina.Slice GetSlice() {
- var _ret_var = Efl.Io.Queue.NativeMethods.efl_io_queue_slice_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Immediately pre-allocate a buffer of at least a given size.</summary>
- /// <param name="size">Amount of bytes to pre-allocate.</param>
- virtual public void Preallocate(uint size) {
- Efl.Io.Queue.NativeMethods.efl_io_queue_preallocate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Discard the given number of bytes.
- /// This has the same effect as reading and discarding the given amount of bytes, without executing the actual copy.
- ///
- /// It's often paired with <see cref="Efl.Io.Queue.GetSlice"/>, if users read the information from the slice and once they're done, that data must be discarded.
- ///
- /// As an example, some protocols provide messages with a "size" header, in which case <see cref="Efl.Io.Queue.GetSlice"/> is used to peek into the available memory to see if there is a "size" and if the rest of the slice is the full payload. In that situation the slice may be handled by a processing function. When the function is complete the defined amount of data must be discarded -- with this function.</summary>
- /// <param name="amount">Bytes to discard</param>
- virtual public void Discard(uint amount) {
- Efl.Io.Queue.NativeMethods.efl_io_queue_discard_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),amount);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Clears the queue. Same as reading all data.
- /// This is equivalent to calling <see cref="Efl.Io.Queue.Discard"/> with <see cref="Efl.Io.Queue.GetUsage"/> amount of bytes.</summary>
- virtual public void Clear() {
- Efl.Io.Queue.NativeMethods.efl_io_queue_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Mark this end-of-stream.
- /// That will set <see cref="Efl.Io.IReader.Eos"/> to <c>true</c> and forbid any further writes.
- ///
- /// Unlike <see cref="Efl.Io.ICloser.Close"/>, this won't clear anything.</summary>
- virtual public void EosMark() {
- Efl.Io.Queue.NativeMethods.efl_io_queue_eos_mark_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>If true will notify object was closed.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if closed, <c>false</c> otherwise</returns>
- virtual public bool GetClosed() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_closed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If true will automatically close resources on exec() calls.
- /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if close on exec(), <c>false</c> otherwise</returns>
- virtual public bool GetCloseOnExec() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_exec_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c>, will close on exec() call.
- /// (Since EFL 1.22)</summary>
- /// <param name="close_on_exec"><c>true</c> if close on exec(), <c>false</c> otherwise</param>
- /// <returns><c>true</c> if could set, <c>false</c> if not supported or failed.</returns>
- virtual public bool SetCloseOnExec(bool close_on_exec) {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_exec_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),close_on_exec);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If true will automatically close() on object invalidate.
- /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if close on invalidate, <c>false</c> otherwise</returns>
- virtual public bool GetCloseOnInvalidate() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If true will automatically close() on object invalidate.
- /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
- /// (Since EFL 1.22)</summary>
- /// <param name="close_on_invalidate"><c>true</c> if close on invalidate, <c>false</c> otherwise</param>
- virtual public void SetCloseOnInvalidate(bool close_on_invalidate) {
- Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),close_on_invalidate);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Closes the Input/Output object.
- /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is to be defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
- ///
- /// You can understand this method as close(2) libc function.
- /// (Since EFL 1.22)</summary>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Close() {
- var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</returns>
- virtual public bool GetCanRead() {
- var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_can_read_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <param name="can_read"><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</param>
- virtual public void SetCanRead(bool can_read) {
- Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_can_read_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),can_read);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>If <c>true</c> will notify end of stream.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if end of stream, <c>false</c> otherwise</returns>
- virtual public bool GetEos() {
- var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_eos_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify end of stream.
- /// (Since EFL 1.22)</summary>
- /// <param name="is_eos"><c>true</c> if end of stream, <c>false</c> otherwise</param>
- virtual public void SetEos(bool is_eos) {
- Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_eos_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),is_eos);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Reads data into a pre-allocated buffer.
- /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is to be defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
- ///
- /// You can understand this method as read(2) libc function.
- /// (Since EFL 1.22)</summary>
- /// <param name="rw_slice">Provides a pre-allocated memory to be filled up to rw_slice.len. It will be populated and the length will be set to the actually used amount of bytes, which can be smaller than the request.</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Read(ref Eina.RwSlice rw_slice) {
- var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_read_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ref rw_slice);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <returns><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</returns>
- virtual public bool GetCanWrite() {
- var _ret_var = Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_can_write_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <param name="can_write"><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</param>
- virtual public void SetCanWrite(bool can_write) {
- Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_can_write_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),can_write);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Writes data from a pre-populated buffer.
- /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
- ///
- /// You can understand this method as write(2) libc function.
- /// (Since EFL 1.22)</summary>
- /// <param name="slice">Provides a pre-populated memory to be used up to slice.len. The returned slice will be adapted as length will be set to the actually used amount of bytes, which can be smaller than the request.</param>
- /// <param name="remaining">Convenience to output the remaining parts of slice that was not written. If the full slice was written, this will be a slice of zero-length.</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- virtual public Eina.Error Write(ref Eina.Slice slice, ref Eina.Slice remaining) {
- var _ret_var = Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_write_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ref slice, ref remaining);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Limit how big the buffer can grow.
- /// This affects both <see cref="Efl.Io.Queue.Preallocate"/> and how buffer grows when <see cref="Efl.Io.IWriter.Write"/> is called.
- ///
- /// If you want a buffer of an exact size, always set the limit before any further calls that can expand it.</summary>
- /// <value>Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</value>
- public uint Limit {
- get { return GetLimit(); }
- set { SetLimit(value); }
- }
- /// <summary>How many bytes are available for read</summary>
- /// <value>Bytes available to read</value>
- public uint Usage {
- get { return GetUsage(); }
- }
- /// <summary>Gain temporary access to queue's internal read memory.
- /// The memory pointed to by slice may be changed by other methods of this class. The event "slice,changed" will be called in those situations.</summary>
- /// <value>Slice of the current buffer, may be invalidated if <see cref="Efl.Io.IWriter.Write"/>, <see cref="Efl.Io.ICloser.Close"/> or <see cref="Efl.Io.IReader.Read"/> are called. It is the full slice available for reading.</value>
- public Eina.Slice Slice {
- get { return GetSlice(); }
- }
- /// <summary>If true will notify object was closed.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if closed, <c>false</c> otherwise</value>
- public bool Closed {
- get { return GetClosed(); }
- }
- /// <summary>If true will automatically close resources on exec() calls.
- /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if close on exec(), <c>false</c> otherwise</value>
- public bool CloseOnExec {
- get { return GetCloseOnExec(); }
- set { SetCloseOnExec(value); }
- }
- /// <summary>If true will automatically close() on object invalidate.
- /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if close on invalidate, <c>false</c> otherwise</value>
- public bool CloseOnInvalidate {
- get { return GetCloseOnInvalidate(); }
- set { SetCloseOnInvalidate(value); }
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</value>
- public bool CanRead {
- get { return GetCanRead(); }
- set { SetCanRead(value); }
- }
- /// <summary>If <c>true</c> will notify end of stream.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if end of stream, <c>false</c> otherwise</value>
- public bool Eos {
- get { return GetEos(); }
- set { SetEos(value); }
- }
- /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
- /// (Since EFL 1.22)</summary>
- /// <value><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</value>
- public bool CanWrite {
- get { return GetCanWrite(); }
- set { SetCanWrite(value); }
- }
- private static IntPtr GetEflClassStatic()
- {
- return Efl.Io.Queue.efl_io_queue_class_get();
- }
- /// <summary>Wrapper for native methods and virtual method delegates.
- /// For internal use by generated code only.</summary>
- public new class NativeMethods : Efl.Object.NativeMethods
- {
- private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Efl);
- /// <summary>Gets the list of Eo operations to override.</summary>
- /// <returns>The list of Eo operations to be overload.</returns>
- public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
- {
- var descs = new System.Collections.Generic.List<Efl_Op_Description>();
- var methods = Efl.Eo.Globals.GetUserMethods(type);
-
- if (efl_io_queue_limit_get_static_delegate == null)
- {
- efl_io_queue_limit_get_static_delegate = new efl_io_queue_limit_get_delegate(limit_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetLimit") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_limit_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_limit_get_static_delegate) });
- }
-
- if (efl_io_queue_limit_set_static_delegate == null)
- {
- efl_io_queue_limit_set_static_delegate = new efl_io_queue_limit_set_delegate(limit_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetLimit") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_limit_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_limit_set_static_delegate) });
- }
-
- if (efl_io_queue_usage_get_static_delegate == null)
- {
- efl_io_queue_usage_get_static_delegate = new efl_io_queue_usage_get_delegate(usage_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetUsage") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_usage_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_usage_get_static_delegate) });
- }
-
- if (efl_io_queue_slice_get_static_delegate == null)
- {
- efl_io_queue_slice_get_static_delegate = new efl_io_queue_slice_get_delegate(slice_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetSlice") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_slice_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_slice_get_static_delegate) });
- }
-
- if (efl_io_queue_preallocate_static_delegate == null)
- {
- efl_io_queue_preallocate_static_delegate = new efl_io_queue_preallocate_delegate(preallocate);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Preallocate") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_preallocate"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_preallocate_static_delegate) });
- }
-
- if (efl_io_queue_discard_static_delegate == null)
- {
- efl_io_queue_discard_static_delegate = new efl_io_queue_discard_delegate(discard);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Discard") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_discard"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_discard_static_delegate) });
- }
-
- if (efl_io_queue_clear_static_delegate == null)
- {
- efl_io_queue_clear_static_delegate = new efl_io_queue_clear_delegate(clear);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Clear") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_clear_static_delegate) });
- }
-
- if (efl_io_queue_eos_mark_static_delegate == null)
- {
- efl_io_queue_eos_mark_static_delegate = new efl_io_queue_eos_mark_delegate(eos_mark);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "EosMark") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_queue_eos_mark"), func = Marshal.GetFunctionPointerForDelegate(efl_io_queue_eos_mark_static_delegate) });
- }
-
- if (efl_io_closer_closed_get_static_delegate == null)
- {
- efl_io_closer_closed_get_static_delegate = new efl_io_closer_closed_get_delegate(closed_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetClosed") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_closed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_closed_get_static_delegate) });
- }
-
- if (efl_io_closer_close_on_exec_get_static_delegate == null)
- {
- efl_io_closer_close_on_exec_get_static_delegate = new efl_io_closer_close_on_exec_get_delegate(close_on_exec_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCloseOnExec") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_exec_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_exec_get_static_delegate) });
- }
-
- if (efl_io_closer_close_on_exec_set_static_delegate == null)
- {
- efl_io_closer_close_on_exec_set_static_delegate = new efl_io_closer_close_on_exec_set_delegate(close_on_exec_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCloseOnExec") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_exec_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_exec_set_static_delegate) });
- }
-
- if (efl_io_closer_close_on_invalidate_get_static_delegate == null)
- {
- efl_io_closer_close_on_invalidate_get_static_delegate = new efl_io_closer_close_on_invalidate_get_delegate(close_on_invalidate_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCloseOnInvalidate") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_invalidate_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_invalidate_get_static_delegate) });
- }
-
- if (efl_io_closer_close_on_invalidate_set_static_delegate == null)
- {
- efl_io_closer_close_on_invalidate_set_static_delegate = new efl_io_closer_close_on_invalidate_set_delegate(close_on_invalidate_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCloseOnInvalidate") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_invalidate_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_invalidate_set_static_delegate) });
- }
-
- if (efl_io_closer_close_static_delegate == null)
- {
- efl_io_closer_close_static_delegate = new efl_io_closer_close_delegate(close);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Close") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_static_delegate) });
- }
-
- if (efl_io_reader_can_read_get_static_delegate == null)
- {
- efl_io_reader_can_read_get_static_delegate = new efl_io_reader_can_read_get_delegate(can_read_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCanRead") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_can_read_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_can_read_get_static_delegate) });
- }
-
- if (efl_io_reader_can_read_set_static_delegate == null)
- {
- efl_io_reader_can_read_set_static_delegate = new efl_io_reader_can_read_set_delegate(can_read_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCanRead") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_can_read_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_can_read_set_static_delegate) });
- }
-
- if (efl_io_reader_eos_get_static_delegate == null)
- {
- efl_io_reader_eos_get_static_delegate = new efl_io_reader_eos_get_delegate(eos_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetEos") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_eos_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_eos_get_static_delegate) });
- }
-
- if (efl_io_reader_eos_set_static_delegate == null)
- {
- efl_io_reader_eos_set_static_delegate = new efl_io_reader_eos_set_delegate(eos_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetEos") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_eos_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_eos_set_static_delegate) });
- }
-
- if (efl_io_reader_read_static_delegate == null)
- {
- efl_io_reader_read_static_delegate = new efl_io_reader_read_delegate(read);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Read") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_read"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_read_static_delegate) });
- }
-
- if (efl_io_writer_can_write_get_static_delegate == null)
- {
- efl_io_writer_can_write_get_static_delegate = new efl_io_writer_can_write_get_delegate(can_write_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetCanWrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_can_write_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_can_write_get_static_delegate) });
- }
-
- if (efl_io_writer_can_write_set_static_delegate == null)
- {
- efl_io_writer_can_write_set_static_delegate = new efl_io_writer_can_write_set_delegate(can_write_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetCanWrite") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_can_write_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_can_write_set_static_delegate) });
- }
-
- if (efl_io_writer_write_static_delegate == null)
- {
- efl_io_writer_write_static_delegate = new efl_io_writer_write_delegate(write);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Write") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_write"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_write_static_delegate) });
- }
-
- descs.AddRange(base.GetEoOps(type));
- return descs;
- }
- /// <summary>Returns the Eo class for the native methods of this class.</summary>
- /// <returns>The native class pointer.</returns>
- public override IntPtr GetEflClass()
- {
- return Efl.Io.Queue.efl_io_queue_class_get();
- }
-
- #pragma warning disable CA1707, CS1591, SA1300, SA1600
-
-
- private delegate uint efl_io_queue_limit_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate uint efl_io_queue_limit_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_limit_get_api_delegate> efl_io_queue_limit_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_limit_get_api_delegate>(Module, "efl_io_queue_limit_get");
-
- private static uint limit_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_queue_limit_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- uint _ret_var = default(uint);
- try
- {
- _ret_var = ((Queue)ws.Target).GetLimit();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_queue_limit_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_queue_limit_get_delegate efl_io_queue_limit_get_static_delegate;
-
-
- private delegate void efl_io_queue_limit_set_delegate(System.IntPtr obj, System.IntPtr pd, uint size);
-
-
- public delegate void efl_io_queue_limit_set_api_delegate(System.IntPtr obj, uint size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_limit_set_api_delegate> efl_io_queue_limit_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_limit_set_api_delegate>(Module, "efl_io_queue_limit_set");
-
- private static void limit_set(System.IntPtr obj, System.IntPtr pd, uint size)
- {
- Eina.Log.Debug("function efl_io_queue_limit_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).SetLimit(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_queue_limit_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_queue_limit_set_delegate efl_io_queue_limit_set_static_delegate;
-
-
- private delegate uint efl_io_queue_usage_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate uint efl_io_queue_usage_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_usage_get_api_delegate> efl_io_queue_usage_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_usage_get_api_delegate>(Module, "efl_io_queue_usage_get");
-
- private static uint usage_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_queue_usage_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- uint _ret_var = default(uint);
- try
- {
- _ret_var = ((Queue)ws.Target).GetUsage();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_queue_usage_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_queue_usage_get_delegate efl_io_queue_usage_get_static_delegate;
-
-
- private delegate Eina.Slice efl_io_queue_slice_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate Eina.Slice efl_io_queue_slice_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_slice_get_api_delegate> efl_io_queue_slice_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_slice_get_api_delegate>(Module, "efl_io_queue_slice_get");
-
- private static Eina.Slice slice_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_queue_slice_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Slice _ret_var = default(Eina.Slice);
- try
- {
- _ret_var = ((Queue)ws.Target).GetSlice();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_queue_slice_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_queue_slice_get_delegate efl_io_queue_slice_get_static_delegate;
-
-
- private delegate void efl_io_queue_preallocate_delegate(System.IntPtr obj, System.IntPtr pd, uint size);
-
-
- public delegate void efl_io_queue_preallocate_api_delegate(System.IntPtr obj, uint size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_preallocate_api_delegate> efl_io_queue_preallocate_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_preallocate_api_delegate>(Module, "efl_io_queue_preallocate");
-
- private static void preallocate(System.IntPtr obj, System.IntPtr pd, uint size)
- {
- Eina.Log.Debug("function efl_io_queue_preallocate was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).Preallocate(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_queue_preallocate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_queue_preallocate_delegate efl_io_queue_preallocate_static_delegate;
-
-
- private delegate void efl_io_queue_discard_delegate(System.IntPtr obj, System.IntPtr pd, uint amount);
-
-
- public delegate void efl_io_queue_discard_api_delegate(System.IntPtr obj, uint amount);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_discard_api_delegate> efl_io_queue_discard_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_discard_api_delegate>(Module, "efl_io_queue_discard");
-
- private static void discard(System.IntPtr obj, System.IntPtr pd, uint amount)
- {
- Eina.Log.Debug("function efl_io_queue_discard was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).Discard(amount);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_queue_discard_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), amount);
- }
- }
-
- private static efl_io_queue_discard_delegate efl_io_queue_discard_static_delegate;
-
-
- private delegate void efl_io_queue_clear_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate void efl_io_queue_clear_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_clear_api_delegate> efl_io_queue_clear_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_clear_api_delegate>(Module, "efl_io_queue_clear");
-
- private static void clear(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_queue_clear was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).Clear();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_queue_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_queue_clear_delegate efl_io_queue_clear_static_delegate;
-
-
- private delegate void efl_io_queue_eos_mark_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate void efl_io_queue_eos_mark_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_queue_eos_mark_api_delegate> efl_io_queue_eos_mark_ptr = new Efl.Eo.FunctionWrapper<efl_io_queue_eos_mark_api_delegate>(Module, "efl_io_queue_eos_mark");
-
- private static void eos_mark(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_queue_eos_mark was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).EosMark();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_queue_eos_mark_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_queue_eos_mark_delegate efl_io_queue_eos_mark_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_closed_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_closed_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_closed_get_api_delegate> efl_io_closer_closed_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_closed_get_api_delegate>(Module, "efl_io_closer_closed_get");
-
- private static bool closed_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_closed_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).GetClosed();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_closed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_closed_get_delegate efl_io_closer_closed_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_close_on_exec_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_close_on_exec_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_get_api_delegate> efl_io_closer_close_on_exec_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_get_api_delegate>(Module, "efl_io_closer_close_on_exec_get");
-
- private static bool close_on_exec_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_exec_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).GetCloseOnExec();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_on_exec_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_close_on_exec_get_delegate efl_io_closer_close_on_exec_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_close_on_exec_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_close_on_exec_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_set_api_delegate> efl_io_closer_close_on_exec_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_set_api_delegate>(Module, "efl_io_closer_close_on_exec_set");
-
- private static bool close_on_exec_set(System.IntPtr obj, System.IntPtr pd, bool close_on_exec)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_exec_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).SetCloseOnExec(close_on_exec);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_on_exec_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), close_on_exec);
- }
- }
-
- private static efl_io_closer_close_on_exec_set_delegate efl_io_closer_close_on_exec_set_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_closer_close_on_invalidate_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_closer_close_on_invalidate_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_get_api_delegate> efl_io_closer_close_on_invalidate_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_get_api_delegate>(Module, "efl_io_closer_close_on_invalidate_get");
-
- private static bool close_on_invalidate_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_invalidate_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).GetCloseOnInvalidate();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_close_on_invalidate_get_delegate efl_io_closer_close_on_invalidate_get_static_delegate;
-
-
- private delegate void efl_io_closer_close_on_invalidate_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
-
-
- public delegate void efl_io_closer_close_on_invalidate_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_set_api_delegate> efl_io_closer_close_on_invalidate_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_set_api_delegate>(Module, "efl_io_closer_close_on_invalidate_set");
-
- private static void close_on_invalidate_set(System.IntPtr obj, System.IntPtr pd, bool close_on_invalidate)
- {
- Eina.Log.Debug("function efl_io_closer_close_on_invalidate_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).SetCloseOnInvalidate(close_on_invalidate);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), close_on_invalidate);
- }
- }
-
- private static efl_io_closer_close_on_invalidate_set_delegate efl_io_closer_close_on_invalidate_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_closer_close_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate Eina.Error efl_io_closer_close_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_closer_close_api_delegate> efl_io_closer_close_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_api_delegate>(Module, "efl_io_closer_close");
-
- private static Eina.Error close(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_closer_close was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Queue)ws.Target).Close();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_closer_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_closer_close_delegate efl_io_closer_close_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_reader_can_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_reader_can_read_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_can_read_get_api_delegate> efl_io_reader_can_read_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_can_read_get_api_delegate>(Module, "efl_io_reader_can_read_get");
-
- private static bool can_read_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_reader_can_read_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).GetCanRead();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_reader_can_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_reader_can_read_get_delegate efl_io_reader_can_read_get_static_delegate;
-
-
- private delegate void efl_io_reader_can_read_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_read);
-
-
- public delegate void efl_io_reader_can_read_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_read);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_can_read_set_api_delegate> efl_io_reader_can_read_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_can_read_set_api_delegate>(Module, "efl_io_reader_can_read_set");
-
- private static void can_read_set(System.IntPtr obj, System.IntPtr pd, bool can_read)
- {
- Eina.Log.Debug("function efl_io_reader_can_read_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).SetCanRead(can_read);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_reader_can_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_read);
- }
- }
-
- private static efl_io_reader_can_read_set_delegate efl_io_reader_can_read_set_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_reader_eos_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_reader_eos_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_eos_get_api_delegate> efl_io_reader_eos_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_eos_get_api_delegate>(Module, "efl_io_reader_eos_get");
-
- private static bool eos_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_reader_eos_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).GetEos();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_reader_eos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_reader_eos_get_delegate efl_io_reader_eos_get_static_delegate;
-
-
- private delegate void efl_io_reader_eos_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool is_eos);
-
-
- public delegate void efl_io_reader_eos_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool is_eos);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_eos_set_api_delegate> efl_io_reader_eos_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_eos_set_api_delegate>(Module, "efl_io_reader_eos_set");
-
- private static void eos_set(System.IntPtr obj, System.IntPtr pd, bool is_eos)
- {
- Eina.Log.Debug("function efl_io_reader_eos_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).SetEos(is_eos);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_reader_eos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), is_eos);
- }
- }
-
- private static efl_io_reader_eos_set_delegate efl_io_reader_eos_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_reader_read_delegate(System.IntPtr obj, System.IntPtr pd, ref Eina.RwSlice rw_slice);
-
-
- public delegate Eina.Error efl_io_reader_read_api_delegate(System.IntPtr obj, ref Eina.RwSlice rw_slice);
-
- public static Efl.Eo.FunctionWrapper<efl_io_reader_read_api_delegate> efl_io_reader_read_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_read_api_delegate>(Module, "efl_io_reader_read");
-
- private static Eina.Error read(System.IntPtr obj, System.IntPtr pd, ref Eina.RwSlice rw_slice)
- {
- Eina.Log.Debug("function efl_io_reader_read was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Queue)ws.Target).Read(ref rw_slice);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_reader_read_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref rw_slice);
- }
- }
-
- private static efl_io_reader_read_delegate efl_io_reader_read_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_writer_can_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_writer_can_write_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_writer_can_write_get_api_delegate> efl_io_writer_can_write_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_can_write_get_api_delegate>(Module, "efl_io_writer_can_write_get");
-
- private static bool can_write_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_writer_can_write_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((Queue)ws.Target).GetCanWrite();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_writer_can_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_writer_can_write_get_delegate efl_io_writer_can_write_get_static_delegate;
-
-
- private delegate void efl_io_writer_can_write_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_write);
-
-
- public delegate void efl_io_writer_can_write_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_write);
-
- public static Efl.Eo.FunctionWrapper<efl_io_writer_can_write_set_api_delegate> efl_io_writer_can_write_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_can_write_set_api_delegate>(Module, "efl_io_writer_can_write_set");
-
- private static void can_write_set(System.IntPtr obj, System.IntPtr pd, bool can_write)
- {
- Eina.Log.Debug("function efl_io_writer_can_write_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Queue)ws.Target).SetCanWrite(can_write);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_io_writer_can_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_write);
- }
- }
-
- private static efl_io_writer_can_write_set_delegate efl_io_writer_can_write_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_writer_write_delegate(System.IntPtr obj, System.IntPtr pd, ref Eina.Slice slice, ref Eina.Slice remaining);
-
-
- public delegate Eina.Error efl_io_writer_write_api_delegate(System.IntPtr obj, ref Eina.Slice slice, ref Eina.Slice remaining);
-
- public static Efl.Eo.FunctionWrapper<efl_io_writer_write_api_delegate> efl_io_writer_write_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_write_api_delegate>(Module, "efl_io_writer_write");
-
- private static Eina.Error write(System.IntPtr obj, System.IntPtr pd, ref Eina.Slice slice, ref Eina.Slice remaining)
- {
- Eina.Log.Debug("function efl_io_writer_write was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- remaining = default(Eina.Slice); Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((Queue)ws.Target).Write(ref slice, ref remaining);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_writer_write_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref slice, ref remaining);
- }
- }
-
- private static efl_io_writer_write_delegate efl_io_writer_write_static_delegate;
-
- #pragma warning restore CA1707, CS1591, SA1300, SA1600
-
-}
-}
-}
-
-}
-
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_io_reader_interface_get();
/// <summary>Initializes a new instance of the <see cref="IReader"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
+++ /dev/null
-#pragma warning disable CS1591
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.ComponentModel;
-namespace Efl {
-
-namespace Io {
-
-/// <summary>Generic interface for objects that can resize or report size of themselves.
-/// This interface allows external objects to transparently resize or report its size.</summary>
-[Efl.Io.ISizerConcrete.NativeMethods]
-public interface ISizer :
- Efl.Eo.IWrapper, IDisposable
-{
- /// <summary>Size property</summary>
-/// <returns>Object size</returns>
-ulong GetSize();
- /// <summary>Try to resize the object, check with get if the value was accepted or not.</summary>
-/// <param name="size">Object size</param>
-/// <returns><c>true</c> if could resize, <c>false</c> if errors.</returns>
-bool SetSize(ulong size);
- /// <summary>Resize object</summary>
-/// <param name="size">Object size</param>
-/// <returns>0 on succeed, a mapping of errno otherwise</returns>
-Eina.Error Resize(ulong size);
- /// <summary>Notifies size changed</summary>
- event EventHandler SizeChangedEvt;
- /// <summary>Size property</summary>
- /// <value>Object size</value>
- ulong Size {
- get ;
- set ;
- }
-}
-/// <summary>Generic interface for objects that can resize or report size of themselves.
-/// This interface allows external objects to transparently resize or report its size.</summary>
-sealed public class ISizerConcrete :
- Efl.Eo.EoWrapper
- , ISizer
-
-{
- ///<summary>Pointer to the native class description.</summary>
- public override System.IntPtr NativeClass
- {
- get
- {
- if (((object)this).GetType() == typeof(ISizerConcrete))
- {
- return GetEflClassStatic();
- }
- else
- {
- return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
- }
- }
- }
-
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
- efl_io_sizer_mixin_get();
- /// <summary>Initializes a new instance of the <see cref="ISizer"/> class.
- /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
- private ISizerConcrete(System.IntPtr raw) : base(raw)
- {
- }
-
- /// <summary>Notifies size changed</summary>
- public event EventHandler SizeChangedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- EventArgs args = EventArgs.Empty;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
- }
- }
- }
- ///<summary>Method to raise event SizeChangedEvt.</summary>
- public void OnSizeChangedEvt(EventArgs e)
- {
- var key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
- }
- /// <summary>Size property</summary>
- /// <returns>Object size</returns>
- public ulong GetSize() {
- var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_size_get_ptr.Value.Delegate(this.NativeHandle);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Try to resize the object, check with get if the value was accepted or not.</summary>
- /// <param name="size">Object size</param>
- /// <returns><c>true</c> if could resize, <c>false</c> if errors.</returns>
- public bool SetSize(ulong size) {
- var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_size_set_ptr.Value.Delegate(this.NativeHandle,size);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Resize object</summary>
- /// <param name="size">Object size</param>
- /// <returns>0 on succeed, a mapping of errno otherwise</returns>
- public Eina.Error Resize(ulong size) {
- var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_resize_ptr.Value.Delegate(this.NativeHandle,size);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Size property</summary>
- /// <value>Object size</value>
- public ulong Size {
- get { return GetSize(); }
- set { SetSize(value); }
- }
- private static IntPtr GetEflClassStatic()
- {
- return Efl.Io.ISizerConcrete.efl_io_sizer_mixin_get();
- }
- /// <summary>Wrapper for native methods and virtual method delegates.
- /// For internal use by generated code only.</summary>
- public class NativeMethods : Efl.Eo.NativeClass
- {
- private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Efl);
- /// <summary>Gets the list of Eo operations to override.</summary>
- /// <returns>The list of Eo operations to be overload.</returns>
- public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
- {
- var descs = new System.Collections.Generic.List<Efl_Op_Description>();
- var methods = Efl.Eo.Globals.GetUserMethods(type);
-
- if (efl_io_sizer_size_get_static_delegate == null)
- {
- efl_io_sizer_size_get_static_delegate = new efl_io_sizer_size_get_delegate(size_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetSize") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_size_get_static_delegate) });
- }
-
- if (efl_io_sizer_size_set_static_delegate == null)
- {
- efl_io_sizer_size_set_static_delegate = new efl_io_sizer_size_set_delegate(size_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetSize") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_size_set_static_delegate) });
- }
-
- if (efl_io_sizer_resize_static_delegate == null)
- {
- efl_io_sizer_resize_static_delegate = new efl_io_sizer_resize_delegate(resize);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Resize") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_resize"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_resize_static_delegate) });
- }
-
- return descs;
- }
- /// <summary>Returns the Eo class for the native methods of this class.</summary>
- /// <returns>The native class pointer.</returns>
- public override IntPtr GetEflClass()
- {
- return Efl.Io.ISizerConcrete.efl_io_sizer_mixin_get();
- }
-
- #pragma warning disable CA1707, CS1591, SA1300, SA1600
-
-
- private delegate ulong efl_io_sizer_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate ulong efl_io_sizer_size_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_io_sizer_size_get_api_delegate> efl_io_sizer_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_size_get_api_delegate>(Module, "efl_io_sizer_size_get");
-
- private static ulong size_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_io_sizer_size_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- ulong _ret_var = default(ulong);
- try
- {
- _ret_var = ((ISizerConcrete)ws.Target).GetSize();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_sizer_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_io_sizer_size_get_delegate efl_io_sizer_size_get_static_delegate;
-
- [return: MarshalAs(UnmanagedType.U1)]
- private delegate bool efl_io_sizer_size_set_delegate(System.IntPtr obj, System.IntPtr pd, ulong size);
-
- [return: MarshalAs(UnmanagedType.U1)]
- public delegate bool efl_io_sizer_size_set_api_delegate(System.IntPtr obj, ulong size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_sizer_size_set_api_delegate> efl_io_sizer_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_size_set_api_delegate>(Module, "efl_io_sizer_size_set");
-
- private static bool size_set(System.IntPtr obj, System.IntPtr pd, ulong size)
- {
- Eina.Log.Debug("function efl_io_sizer_size_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- bool _ret_var = default(bool);
- try
- {
- _ret_var = ((ISizerConcrete)ws.Target).SetSize(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_sizer_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_sizer_size_set_delegate efl_io_sizer_size_set_static_delegate;
-
-
- private delegate Eina.Error efl_io_sizer_resize_delegate(System.IntPtr obj, System.IntPtr pd, ulong size);
-
-
- public delegate Eina.Error efl_io_sizer_resize_api_delegate(System.IntPtr obj, ulong size);
-
- public static Efl.Eo.FunctionWrapper<efl_io_sizer_resize_api_delegate> efl_io_sizer_resize_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_resize_api_delegate>(Module, "efl_io_sizer_resize");
-
- private static Eina.Error resize(System.IntPtr obj, System.IntPtr pd, ulong size)
- {
- Eina.Log.Debug("function efl_io_sizer_resize was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Eina.Error _ret_var = default(Eina.Error);
- try
- {
- _ret_var = ((ISizerConcrete)ws.Target).Resize(size);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_io_sizer_resize_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
- }
- }
-
- private static efl_io_sizer_resize_delegate efl_io_sizer_resize_static_delegate;
-
- #pragma warning restore CA1707, CS1591, SA1300, SA1600
-
-}
-}
-}
-
-}
-
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_io_writer_interface_get();
/// <summary>Initializes a new instance of the <see cref="IWriter"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
/// Note: The time point must match whatever zero time you get from ecore_time_get() and <see cref="Efl.Loop.GetTime"/> (same 0 point). What this point is is undefined, so unless your source uses the same 0 time, then you may have to adjust and do some guessing.
/// (Since EFL 1.22)</summary>
/// <param name="timepoint">Time in seconds</param>
- virtual public void SetTime(double timepoint) {
+ virtual protected void SetTime(double timepoint) {
Efl.Loop.NativeMethods.efl_loop_time_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),timepoint);
Eina.Error.RaiseIfUnhandledException();
}
/// <value>Time in seconds</value>
public double Time {
get { return GetTime(); }
- set { SetTime(value); }
+ protected set { SetTime(value); }
}
private static IntPtr GetEflClassStatic()
{
};
string key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnPropertiesChangedEvt(Efl.IModelPropertiesChangedEvt_Args e)
{
var key = "_EFL_MODEL_EVENT_PROPERTIES_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_MODEL_EVENT_CHILD_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_MODEL_EVENT_CHILD_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnChildAddedEvt(Efl.IModelChildAddedEvt_Args e)
{
var key = "_EFL_MODEL_EVENT_CHILD_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnChildRemovedEvt(Efl.IModelChildRemovedEvt_Args e)
{
var key = "_EFL_MODEL_EVENT_CHILD_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnChildrenCountChangedEvt(EventArgs e)
{
var key = "_EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_model_interface_get();
/// <summary>Initializes a new instance of the <see cref="IModel"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_observable_class_get();
/// <summary>Initializes a new instance of the <see cref="Observable"/> class.</summary>
/// <param name="parent">Parent instance.</param>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_observer_interface_get();
/// <summary>Initializes a new instance of the <see cref="IObserver"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_pack_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPack"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_pack_layout_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPackLayout"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_pack_linear_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPackLinear"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_pack_table_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPackTable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_part_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPart"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_playable_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPlayable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_player_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPlayer"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_screen_interface_get();
/// <summary>Initializes a new instance of the <see cref="IScreen"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_interface_get();
/// <summary>Initializes a new instance of the <see cref="IText"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_annotate_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextAnnotate"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_cursor_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextCursor"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_font_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextFont"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_format_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextFormat"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_markup_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextMarkup"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_markup_interactive_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextMarkupInteractive"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_markup_util_class_get();
/// <summary>Initializes a new instance of the <see cref="TextMarkupUtil"/> class.</summary>
/// <param name="parent">Parent instance.</param>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_text_style_interface_get();
/// <summary>Initializes a new instance of the <see cref="ITextStyle"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnClosedEvt(EventArgs e)
{
var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
{
var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_READER_EVENT_EOS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_READER_EVENT_EOS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnEosEvt(EventArgs e)
{
var key = "_EFL_IO_READER_EVENT_EOS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
}
}
}
public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
{
var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
System.IntPtr _ret_var = default(System.IntPtr);
try
{
- _ret_var = ((IThreadIOConcrete)ws.Target).GetIndata();
+ _ret_var = ((IThreadIO)ws.Target).GetIndata();
}
catch (Exception e)
{
try
{
- ((IThreadIOConcrete)ws.Target).SetIndata(data);
+ ((IThreadIO)ws.Target).SetIndata(data);
}
catch (Exception e)
{
System.IntPtr _ret_var = default(System.IntPtr);
try
{
- _ret_var = ((IThreadIOConcrete)ws.Target).GetOutdata();
+ _ret_var = ((IThreadIO)ws.Target).GetOutdata();
}
catch (Exception e)
{
try
{
- ((IThreadIOConcrete)ws.Target).SetOutdata(data);
+ ((IThreadIO)ws.Target).SetOutdata(data);
}
catch (Exception e)
{
try
{
- ((IThreadIOConcrete)ws.Target).Call(func_wrapper.ManagedCb);
+ ((IThreadIO)ws.Target).Call(func_wrapper.ManagedCb);
}
catch (Exception e)
{
System.IntPtr _ret_var = default(System.IntPtr);
try
{
- _ret_var = ((IThreadIOConcrete)ws.Target).CallSync(func_wrapper.ManagedCb);
+ _ret_var = ((IThreadIO)ws.Target).CallSync(func_wrapper.ManagedCb);
}
catch (Exception e)
{
Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_active_index_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
Eina.Error.RaiseIfUnhandledException();
}
- /// <summary>When a new view is added to this widget, the indices for the previous views might change (for example, when adding a view at the beginning of the list with <see cref="Efl.IPackLinear.PackBegin"/> all previous view's indices are increased by one).
- /// This property controls whether the Active View should remain the same view as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>) or if the Active View should be moved to the one with the same index as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/>).
- ///
- /// For example, <see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/> can be used to build a Stack, where <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> is always 0 and new views are pushed onto the stack with <see cref="Efl.IPackLinear.PackBegin"/> and popped from the stack with <see cref="Efl.IPackLinear.PackUnpackAt"/> 0.</summary>
- /// <returns>Active View behavior when adding new views. Default is <see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>.</returns>
- virtual public Efl.Ui.ActiveView.ContainerGravity GetActiveViewGravity() {
- var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_gravity_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>When a new view is added to this widget, the indices for the previous views might change (for example, when adding a view at the beginning of the list with <see cref="Efl.IPackLinear.PackBegin"/> all previous view's indices are increased by one).
- /// This property controls whether the Active View should remain the same view as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>) or if the Active View should be moved to the one with the same index as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/>).
- ///
- /// For example, <see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/> can be used to build a Stack, where <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> is always 0 and new views are pushed onto the stack with <see cref="Efl.IPackLinear.PackBegin"/> and popped from the stack with <see cref="Efl.IPackLinear.PackUnpackAt"/> 0.</summary>
- /// <param name="gravity">Active View behavior when adding new views. Default is <see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>.</param>
- virtual public void SetActiveViewGravity(Efl.Ui.ActiveView.ContainerGravity gravity) {
- Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_gravity_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),gravity);
- Eina.Error.RaiseIfUnhandledException();
- }
/// <summary>The size to use when displaying the Active View. This is used by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> to perform the rendering. Views other than the Active one may or may not use this size.</summary>
/// <returns>Render size for the Active View. (-1, -1) means that all available space inside the container is used.</returns>
virtual public Eina.Size2D GetActiveViewSize() {
Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_size);
Eina.Error.RaiseIfUnhandledException();
}
+ /// <summary>Packs a new view at the position indicated by <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> (0 by default).
+ /// This is the same behavior as a push operation on a stack.
+ ///
+ /// An animation might be triggered to make the new active view come into position.</summary>
+ /// <param name="view">View to add and set to be the active view.</param>
+ virtual public void Push(Efl.Gfx.IEntity view) {
+ Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_push_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),view);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Removes the active view from the widget.
+ /// The views behind it naturally flow down so the next one becomes the active view. This is the same behavior as a pop operation on a stack. When combined with <see cref="Efl.Ui.ActiveView.Container.Push"/> you don't have to worry about <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> since only the first view is manipulated.
+ ///
+ /// An animation might be triggered to make the new active view come into position and the old one disappear.
+ ///
+ /// The removed view can be returned to the caller or deleted (depending on <c>delete_on_transition_end</c>).</summary>
+ /// <param name="deletion_on_transition_end">if <c>true</c>, then the object will be deleted before resolving the future, and a NULL pointer is the value of the future. <c>false</c> if no operation should be applied to it</param>
+ /// <returns>This Future gets resolved when any transition animation finishes and the popped view is ready for collection. If there is no animation, the Future resolves immediately. If <c>deletion_on_transition_end</c> is <c>true</c> then this widget will destroy the popped view and the Future will contain no Value. Otherwise, the caller becomes the owner of the view contained in the Future and must dispose of it appropriately.</returns>
+ virtual public Eina.Future Pop(bool deletion_on_transition_end) {
+ var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_pop_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),deletion_on_transition_end);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
/// <summary>Removes all packed sub-objects and unreferences them.</summary>
/// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
virtual public bool ClearPack() {
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
+ /// <summary>Async wrapper for <see cref="Pop" />.</summary>
+ /// <param name="deletion_on_transition_end">if <c>true</c>, then the object will be deleted before resolving the future, and a NULL pointer is the value of the future. <c>false</c> if no operation should be applied to it</param>
+ /// <param name="token">Token to notify the async operation of external request to cancel.</param>
+ /// <returns>An async task wrapping the result of the operation.</returns>
+ public System.Threading.Tasks.Task<Eina.Value> PopAsync(bool deletion_on_transition_end, System.Threading.CancellationToken token = default(System.Threading.CancellationToken))
+ {
+ Eina.Future future = Pop( deletion_on_transition_end);
+ return Efl.Eo.Globals.WrapAsync(future, token);
+ }
+
/// <summary>This object defines how views are rendered and animated. If it is not set, only the active view is shown and transitions are instantaneous (not animated).</summary>
/// <value>The View Manager object or <c>NULL</c>.</value>
public Efl.Ui.ActiveView.ViewManager ViewManager {
get { return GetActiveIndex(); }
set { SetActiveIndex(value); }
}
- /// <summary>When a new view is added to this widget, the indices for the previous views might change (for example, when adding a view at the beginning of the list with <see cref="Efl.IPackLinear.PackBegin"/> all previous view's indices are increased by one).
- /// This property controls whether the Active View should remain the same view as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>) or if the Active View should be moved to the one with the same index as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/>).
- ///
- /// For example, <see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/> can be used to build a Stack, where <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> is always 0 and new views are pushed onto the stack with <see cref="Efl.IPackLinear.PackBegin"/> and popped from the stack with <see cref="Efl.IPackLinear.PackUnpackAt"/> 0.</summary>
- /// <value>Active View behavior when adding new views. Default is <see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>.</value>
- public Efl.Ui.ActiveView.ContainerGravity ActiveViewGravity {
- get { return GetActiveViewGravity(); }
- set { SetActiveViewGravity(value); }
- }
/// <summary>The size to use when displaying the Active View. This is used by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> to perform the rendering. Views other than the Active one may or may not use this size.</summary>
/// <value>Render size for the Active View. (-1, -1) means that all available space inside the container is used.</value>
public Eina.Size2D ActiveViewSize {
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_active_index_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_active_index_set_static_delegate) });
}
- if (efl_ui_active_view_gravity_get_static_delegate == null)
+ if (efl_ui_active_view_size_get_static_delegate == null)
{
- efl_ui_active_view_gravity_get_static_delegate = new efl_ui_active_view_gravity_get_delegate(active_view_gravity_get);
+ efl_ui_active_view_size_get_static_delegate = new efl_ui_active_view_size_get_delegate(active_view_size_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetActiveViewGravity") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetActiveViewSize") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_gravity_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_gravity_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_size_get_static_delegate) });
}
- if (efl_ui_active_view_gravity_set_static_delegate == null)
+ if (efl_ui_active_view_size_set_static_delegate == null)
{
- efl_ui_active_view_gravity_set_static_delegate = new efl_ui_active_view_gravity_set_delegate(active_view_gravity_set);
+ efl_ui_active_view_size_set_static_delegate = new efl_ui_active_view_size_set_delegate(active_view_size_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetActiveViewGravity") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetActiveViewSize") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_gravity_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_gravity_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_size_set_static_delegate) });
}
- if (efl_ui_active_view_size_get_static_delegate == null)
+ if (efl_ui_active_view_push_static_delegate == null)
{
- efl_ui_active_view_size_get_static_delegate = new efl_ui_active_view_size_get_delegate(active_view_size_get);
+ efl_ui_active_view_push_static_delegate = new efl_ui_active_view_push_delegate(push);
}
- if (methods.FirstOrDefault(m => m.Name == "GetActiveViewSize") != null)
+ if (methods.FirstOrDefault(m => m.Name == "Push") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_size_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_push"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_push_static_delegate) });
}
- if (efl_ui_active_view_size_set_static_delegate == null)
+ if (efl_ui_active_view_pop_static_delegate == null)
{
- efl_ui_active_view_size_set_static_delegate = new efl_ui_active_view_size_set_delegate(active_view_size_set);
+ efl_ui_active_view_pop_static_delegate = new efl_ui_active_view_pop_delegate(pop);
}
- if (methods.FirstOrDefault(m => m.Name == "SetActiveViewSize") != null)
+ if (methods.FirstOrDefault(m => m.Name == "Pop") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_size_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_pop"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_pop_static_delegate) });
}
if (efl_pack_clear_static_delegate == null)
private static efl_ui_active_view_active_index_set_delegate efl_ui_active_view_active_index_set_static_delegate;
- private delegate Efl.Ui.ActiveView.ContainerGravity efl_ui_active_view_gravity_get_delegate(System.IntPtr obj, System.IntPtr pd);
+ private delegate Eina.Size2D.NativeStruct efl_ui_active_view_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
- public delegate Efl.Ui.ActiveView.ContainerGravity efl_ui_active_view_gravity_get_api_delegate(System.IntPtr obj);
+ public delegate Eina.Size2D.NativeStruct efl_ui_active_view_size_get_api_delegate(System.IntPtr obj);
- public static Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_get_api_delegate> efl_ui_active_view_gravity_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_get_api_delegate>(Module, "efl_ui_active_view_gravity_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_active_view_size_get_api_delegate> efl_ui_active_view_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_size_get_api_delegate>(Module, "efl_ui_active_view_size_get");
- private static Efl.Ui.ActiveView.ContainerGravity active_view_gravity_get(System.IntPtr obj, System.IntPtr pd)
+ private static Eina.Size2D.NativeStruct active_view_size_get(System.IntPtr obj, System.IntPtr pd)
{
- Eina.Log.Debug("function efl_ui_active_view_gravity_get was called");
+ Eina.Log.Debug("function efl_ui_active_view_size_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- Efl.Ui.ActiveView.ContainerGravity _ret_var = default(Efl.Ui.ActiveView.ContainerGravity);
+ Eina.Size2D _ret_var = default(Eina.Size2D);
try
{
- _ret_var = ((Container)ws.Target).GetActiveViewGravity();
+ _ret_var = ((Container)ws.Target).GetActiveViewSize();
}
catch (Exception e)
{
}
else
{
- return efl_ui_active_view_gravity_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ return efl_ui_active_view_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
}
}
- private static efl_ui_active_view_gravity_get_delegate efl_ui_active_view_gravity_get_static_delegate;
+ private static efl_ui_active_view_size_get_delegate efl_ui_active_view_size_get_static_delegate;
- private delegate void efl_ui_active_view_gravity_set_delegate(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ActiveView.ContainerGravity gravity);
+ private delegate void efl_ui_active_view_size_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size);
- public delegate void efl_ui_active_view_gravity_set_api_delegate(System.IntPtr obj, Efl.Ui.ActiveView.ContainerGravity gravity);
+ public delegate void efl_ui_active_view_size_set_api_delegate(System.IntPtr obj, Eina.Size2D.NativeStruct size);
- public static Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_set_api_delegate> efl_ui_active_view_gravity_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_set_api_delegate>(Module, "efl_ui_active_view_gravity_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_active_view_size_set_api_delegate> efl_ui_active_view_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_size_set_api_delegate>(Module, "efl_ui_active_view_size_set");
- private static void active_view_gravity_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ActiveView.ContainerGravity gravity)
+ private static void active_view_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
{
- Eina.Log.Debug("function efl_ui_active_view_gravity_set was called");
+ Eina.Log.Debug("function efl_ui_active_view_size_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
-
+ Eina.Size2D _in_size = size;
+
try
{
- ((Container)ws.Target).SetActiveViewGravity(gravity);
+ ((Container)ws.Target).SetActiveViewSize(_in_size);
}
catch (Exception e)
{
}
else
{
- efl_ui_active_view_gravity_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), gravity);
+ efl_ui_active_view_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
}
}
- private static efl_ui_active_view_gravity_set_delegate efl_ui_active_view_gravity_set_static_delegate;
+ private static efl_ui_active_view_size_set_delegate efl_ui_active_view_size_set_static_delegate;
- private delegate Eina.Size2D.NativeStruct efl_ui_active_view_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
+ private delegate void efl_ui_active_view_push_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity view);
- public delegate Eina.Size2D.NativeStruct efl_ui_active_view_size_get_api_delegate(System.IntPtr obj);
+ public delegate void efl_ui_active_view_push_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity view);
- public static Efl.Eo.FunctionWrapper<efl_ui_active_view_size_get_api_delegate> efl_ui_active_view_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_size_get_api_delegate>(Module, "efl_ui_active_view_size_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_active_view_push_api_delegate> efl_ui_active_view_push_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_push_api_delegate>(Module, "efl_ui_active_view_push");
- private static Eina.Size2D.NativeStruct active_view_size_get(System.IntPtr obj, System.IntPtr pd)
+ private static void push(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity view)
{
- Eina.Log.Debug("function efl_ui_active_view_size_get was called");
+ Eina.Log.Debug("function efl_ui_active_view_push was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- Eina.Size2D _ret_var = default(Eina.Size2D);
+
try
{
- _ret_var = ((Container)ws.Target).GetActiveViewSize();
+ ((Container)ws.Target).Push(view);
}
catch (Exception e)
{
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
- return _ret_var;
-
+
}
else
{
- return efl_ui_active_view_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ efl_ui_active_view_push_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), view);
}
}
- private static efl_ui_active_view_size_get_delegate efl_ui_active_view_size_get_static_delegate;
+ private static efl_ui_active_view_push_delegate efl_ui_active_view_push_static_delegate;
-
- private delegate void efl_ui_active_view_size_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size);
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
+ private delegate Eina.Future efl_ui_active_view_pop_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool deletion_on_transition_end);
-
- public delegate void efl_ui_active_view_size_set_api_delegate(System.IntPtr obj, Eina.Size2D.NativeStruct size);
+ [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]
+ public delegate Eina.Future efl_ui_active_view_pop_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool deletion_on_transition_end);
- public static Efl.Eo.FunctionWrapper<efl_ui_active_view_size_set_api_delegate> efl_ui_active_view_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_size_set_api_delegate>(Module, "efl_ui_active_view_size_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_active_view_pop_api_delegate> efl_ui_active_view_pop_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_pop_api_delegate>(Module, "efl_ui_active_view_pop");
- private static void active_view_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
+ private static Eina.Future pop(System.IntPtr obj, System.IntPtr pd, bool deletion_on_transition_end)
{
- Eina.Log.Debug("function efl_ui_active_view_size_set was called");
+ Eina.Log.Debug("function efl_ui_active_view_pop was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
- Eina.Size2D _in_size = size;
-
+ Eina.Future _ret_var = default( Eina.Future);
try
{
- ((Container)ws.Target).SetActiveViewSize(_in_size);
+ _ret_var = ((Container)ws.Target).Pop(deletion_on_transition_end);
}
catch (Exception e)
{
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
}
-
+ return _ret_var;
+
}
else
{
- efl_ui_active_view_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
+ return efl_ui_active_view_pop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), deletion_on_transition_end);
}
}
- private static efl_ui_active_view_size_set_delegate efl_ui_active_view_size_set_static_delegate;
+ private static efl_ui_active_view_pop_delegate efl_ui_active_view_pop_static_delegate;
[return: MarshalAs(UnmanagedType.U1)]
private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
namespace ActiveView {
-/// <summary>This enum controls the behavior of <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> when indices are shifted due to object addition or removal.</summary>
-public enum ContainerGravity
-{
-/// <summary>When a view is added or removed from the container, the <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> will be adjusted as necessary so it points to the same view as before.</summary>
-Content = 0,
-/// <summary>When a view is added or removed from the container, the <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> will remain the same, possibly pointing to a different view.</summary>
-Index = 1,
-}
-
-}
-
-}
-
-}
-
-namespace Efl {
-
-namespace Ui {
-
-namespace ActiveView {
-
/// <summary>Information regarding transition events.</summary>
[StructLayout(LayoutKind.Sequential)]
public struct TransitionEvent
--- /dev/null
+#pragma warning disable CS1591
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.ComponentModel;
+namespace Efl {
+
+namespace Ui {
+
+namespace ActiveView {
+
+[Efl.Ui.ActiveView.Util.NativeMethods]
+public class Util : Efl.Eo.EoWrapper
+{
+ ///<summary>Pointer to the native class description.</summary>
+ public override System.IntPtr NativeClass
+ {
+ get
+ {
+ if (((object)this).GetType() == typeof(Util))
+ {
+ return GetEflClassStatic();
+ }
+ else
+ {
+ return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
+ }
+ }
+ }
+
+ [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
+ efl_ui_active_view_util_class_get();
+ /// <summary>Initializes a new instance of the <see cref="Util"/> class.</summary>
+ /// <param name="parent">Parent instance.</param>
+ public Util(Efl.Object parent= null
+ ) : base(efl_ui_active_view_util_class_get(), typeof(Util), parent)
+ {
+ FinishInstantiation();
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="Util"/> class.
+ /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
+ /// <param name="raw">The native pointer to be wrapped.</param>
+ protected Util(System.IntPtr raw) : base(raw)
+ {
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="Util"/> class.
+ /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
+ /// <param name="baseKlass">The pointer to the base native Eo class.</param>
+ /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
+ /// <param name="parent">The Efl.Object parent of this instance.</param>
+ protected Util(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
+ {
+ }
+
+ /// <summary>Get a preconfigured stack obejct</summary>
+ public static Efl.Ui.ActiveView.Container StackGen(Efl.Ui.Widget parent) {
+ var _ret_var = Efl.Ui.ActiveView.Util.NativeMethods.efl_ui_active_view_util_stack_gen_ptr.Value.Delegate(parent);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ private static IntPtr GetEflClassStatic()
+ {
+ return Efl.Ui.ActiveView.Util.efl_ui_active_view_util_class_get();
+ }
+ /// <summary>Wrapper for native methods and virtual method delegates.
+ /// For internal use by generated code only.</summary>
+ public class NativeMethods : Efl.Eo.NativeClass
+ {
+ private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Elementary);
+ /// <summary>Gets the list of Eo operations to override.</summary>
+ /// <returns>The list of Eo operations to be overload.</returns>
+ public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
+ {
+ var descs = new System.Collections.Generic.List<Efl_Op_Description>();
+ return descs;
+ }
+ /// <summary>Returns the Eo class for the native methods of this class.</summary>
+ /// <returns>The native class pointer.</returns>
+ public override IntPtr GetEflClass()
+ {
+ return Efl.Ui.ActiveView.Util.efl_ui_active_view_util_class_get();
+ }
+
+ #pragma warning disable CA1707, CS1591, SA1300, SA1600
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Ui.ActiveView.Container efl_ui_active_view_util_stack_gen_delegate([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Widget parent);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Ui.ActiveView.Container efl_ui_active_view_util_stack_gen_api_delegate([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Widget parent);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_active_view_util_stack_gen_api_delegate> efl_ui_active_view_util_stack_gen_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_util_stack_gen_api_delegate>(Module, "efl_ui_active_view_util_stack_gen");
+
+ private static Efl.Ui.ActiveView.Container stack_gen(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Widget parent)
+ {
+ Eina.Log.Debug("function efl_ui_active_view_util_stack_gen was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Ui.ActiveView.Container _ret_var = default(Efl.Ui.ActiveView.Container);
+ try
+ {
+ _ret_var = Util.StackGen(parent);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_active_view_util_stack_gen_ptr.Value.Delegate(parent);
+ }
+ }
+
+ #pragma warning restore CA1707, CS1591, SA1300, SA1600
+
+}
+}
+}
+
+}
+
+}
+
+++ /dev/null
-#pragma warning disable CS1591
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.ComponentModel;
-namespace Efl {
-
-namespace Ui {
-
-namespace ActiveView {
-
-[Efl.Ui.ActiveView.ViewManagerPlain.NativeMethods]
-public class ViewManagerPlain : Efl.Ui.ActiveView.ViewManager
-{
- ///<summary>Pointer to the native class description.</summary>
- public override System.IntPtr NativeClass
- {
- get
- {
- if (((object)this).GetType() == typeof(ViewManagerPlain))
- {
- return GetEflClassStatic();
- }
- else
- {
- return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
- }
- }
- }
-
- [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
- efl_ui_active_view_view_manager_plain_class_get();
- /// <summary>Initializes a new instance of the <see cref="ViewManagerPlain"/> class.</summary>
- /// <param name="parent">Parent instance.</param>
- public ViewManagerPlain(Efl.Object parent= null
- ) : base(efl_ui_active_view_view_manager_plain_class_get(), typeof(ViewManagerPlain), parent)
- {
- FinishInstantiation();
- }
-
- /// <summary>Initializes a new instance of the <see cref="ViewManagerPlain"/> class.
- /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
- /// <param name="raw">The native pointer to be wrapped.</param>
- protected ViewManagerPlain(System.IntPtr raw) : base(raw)
- {
- }
-
- /// <summary>Initializes a new instance of the <see cref="ViewManagerPlain"/> class.
- /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
- /// <param name="baseKlass">The pointer to the base native Eo class.</param>
- /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
- /// <param name="parent">The Efl.Object parent of this instance.</param>
- protected ViewManagerPlain(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
- {
- }
-
- private static IntPtr GetEflClassStatic()
- {
- return Efl.Ui.ActiveView.ViewManagerPlain.efl_ui_active_view_view_manager_plain_class_get();
- }
- /// <summary>Wrapper for native methods and virtual method delegates.
- /// For internal use by generated code only.</summary>
- public new class NativeMethods : Efl.Ui.ActiveView.ViewManager.NativeMethods
- {
- /// <summary>Gets the list of Eo operations to override.</summary>
- /// <returns>The list of Eo operations to be overload.</returns>
- public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
- {
- var descs = new System.Collections.Generic.List<Efl_Op_Description>();
- descs.AddRange(base.GetEoOps(type));
- return descs;
- }
- /// <summary>Returns the Eo class for the native methods of this class.</summary>
- /// <returns>The native class pointer.</returns>
- public override IntPtr GetEflClass()
- {
- return Efl.Ui.ActiveView.ViewManagerPlain.efl_ui_active_view_view_manager_plain_class_get();
- }
-
- #pragma warning disable CA1707, CS1591, SA1300, SA1600
-
- #pragma warning restore CA1707, CS1591, SA1300, SA1600
-
-}
-}
-}
-
-}
-
-}
-
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_autorepeat_interface_get();
/// <summary>Initializes a new instance of the <see cref="IAutorepeat"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImagePreloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImageResizeEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImageUnloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLoadDoneEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
{
var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLayoutUpdatedEvt(EventArgs e)
{
var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_AUTOREPEAT_EVENT_REPEATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_AUTOREPEAT_EVENT_REPEATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnRepeatedEvt(EventArgs e)
{
var key = "_EFL_UI_AUTOREPEAT_EVENT_REPEATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
try
{
- ((IClickableConcrete)ws.Target).Press(button);
+ ((IClickable)ws.Target).Press(button);
}
catch (Exception e)
{
try
{
- ((IClickableConcrete)ws.Target).Unpress(button);
+ ((IClickable)ws.Target).Unpress(button);
}
catch (Exception e)
{
try
{
- ((IClickableConcrete)ws.Target).ResetButtonState(button);
+ ((IClickable)ws.Target).ResetButtonState(button);
}
catch (Exception e)
{
try
{
- ((IDndConcrete)ws.Target).DragStart(format, data, action, icon_func_wrapper.ManagedCb, seat);
+ ((IDnd)ws.Target).DragStart(format, data, action, icon_func_wrapper.ManagedCb, seat);
}
catch (Exception e)
{
try
{
- ((IDndConcrete)ws.Target).SetDragAction(action, seat);
+ ((IDnd)ws.Target).SetDragAction(action, seat);
}
catch (Exception e)
{
try
{
- ((IDndConcrete)ws.Target).DragCancel(seat);
+ ((IDnd)ws.Target).DragCancel(seat);
}
catch (Exception e)
{
try
{
- ((IDndConcrete)ws.Target).AddDropTarget(format, seat);
+ ((IDnd)ws.Target).AddDropTarget(format, seat);
}
catch (Exception e)
{
try
{
- ((IDndConcrete)ws.Target).DelDropTarget(format, seat);
+ ((IDnd)ws.Target).DelDropTarget(format, seat);
}
catch (Exception e)
{
double _ret_var = default(double);
try
{
- _ret_var = ((IDndContainerConcrete)ws.Target).GetDragDelayTime();
+ _ret_var = ((IDndContainer)ws.Target).GetDragDelayTime();
}
catch (Exception e)
{
try
{
- ((IDndContainerConcrete)ws.Target).SetDragDelayTime(time);
+ ((IDndContainer)ws.Target).SetDragDelayTime(time);
}
catch (Exception e)
{
try
{
- ((IDndContainerConcrete)ws.Target).AddDragItem(data_func_wrapper.ManagedCb, item_func_wrapper.ManagedCb, icon_func_wrapper.ManagedCb, icon_list_func_wrapper.ManagedCb, seat);
+ ((IDndContainer)ws.Target).AddDragItem(data_func_wrapper.ManagedCb, item_func_wrapper.ManagedCb, icon_func_wrapper.ManagedCb, icon_list_func_wrapper.ManagedCb, seat);
}
catch (Exception e)
{
try
{
- ((IDndContainerConcrete)ws.Target).DelDragItem(seat);
+ ((IDndContainer)ws.Target).DelDragItem(seat);
}
catch (Exception e)
{
try
{
- ((IDndContainerConcrete)ws.Target).AddDropItem(format, item_func_wrapper.ManagedCb, seat);
+ ((IDndContainer)ws.Target).AddDropItem(format, item_func_wrapper.ManagedCb, seat);
}
catch (Exception e)
{
try
{
- ((IDndContainerConcrete)ws.Target).DelDropItem(seat);
+ ((IDndContainer)ws.Target).DelDropItem(seat);
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_drag_interface_get();
/// <summary>Initializes a new instance of the <see cref="IDrag"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_draggable_interface_get();
/// <summary>Initializes a new instance of the <see cref="IDraggable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_factory_interface_get();
/// <summary>Initializes a new instance of the <see cref="IFactory"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_factory_bind_interface_get();
/// <summary>Initializes a new instance of the <see cref="IFactoryBind"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
Eina.List<Efl.Gfx.IEntity> _ret_var = default(Eina.List<Efl.Gfx.IEntity>);
try
{
- _ret_var = ((ICompositionConcrete)ws.Target).GetCompositionElements();
+ _ret_var = ((IComposition)ws.Target).GetCompositionElements();
}
catch (Exception e)
{
try
{
- ((ICompositionConcrete)ws.Target).SetCompositionElements(_in_logical_order);
+ ((IComposition)ws.Target).SetCompositionElements(_in_logical_order);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((ICompositionConcrete)ws.Target).GetLogicalMode();
+ _ret_var = ((IComposition)ws.Target).GetLogicalMode();
}
catch (Exception e)
{
try
{
- ((ICompositionConcrete)ws.Target).SetLogicalMode(logical_mode);
+ ((IComposition)ws.Target).SetLogicalMode(logical_mode);
}
catch (Exception e)
{
try
{
- ((ICompositionConcrete)ws.Target).Dirty();
+ ((IComposition)ws.Target).Dirty();
}
catch (Exception e)
{
try
{
- ((ICompositionConcrete)ws.Target).Prepare();
+ ((IComposition)ws.Target).Prepare();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).GetEnable();
+ _ret_var = ((ILayer)ws.Target).GetEnable();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).SetEnable(v);
+ ((ILayer)ws.Target).SetEnable(v);
}
catch (Exception e)
{
enable_on_visible = default(bool); cycle = default(bool);
try
{
- ((ILayerConcrete)ws.Target).GetBehaviour(out enable_on_visible, out cycle);
+ ((ILayer)ws.Target).GetBehaviour(out enable_on_visible, out cycle);
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).SetBehaviour(enable_on_visible, cycle);
+ ((ILayer)ws.Target).SetBehaviour(enable_on_visible, cycle);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).FocusManagerCreate(root);
+ _ret_var = ((ILayer)ws.Target).FocusManagerCreate(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).GetManagerFocus();
+ _ret_var = ((ILayer)ws.Target).GetManagerFocus();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).SetManagerFocus(focus);
+ ((ILayer)ws.Target).SetManagerFocus(focus);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).GetRedirect();
+ _ret_var = ((ILayer)ws.Target).GetRedirect();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).SetRedirect(redirect);
+ ((ILayer)ws.Target).SetRedirect(redirect);
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).GetBorderElements();
+ _ret_var = ((ILayer)ws.Target).GetBorderElements();
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).GetViewportElements(_in_viewport);
+ _ret_var = ((ILayer)ws.Target).GetViewportElements(_in_viewport);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).GetRoot();
+ _ret_var = ((ILayer)ws.Target).GetRoot();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).SetRoot(root);
+ _ret_var = ((ILayer)ws.Target).SetRoot(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).Move(direction);
+ _ret_var = ((ILayer)ws.Target).Move(direction);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).MoveRequest(direction, child, logical);
+ _ret_var = ((ILayer)ws.Target).MoveRequest(direction, child, logical);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).RequestSubchild(root);
+ _ret_var = ((ILayer)ws.Target).RequestSubchild(root);
}
catch (Exception e)
{
Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).Fetch(child);
+ _ret_var = ((ILayer)ws.Target).Fetch(child);
}
catch (Exception e)
{
Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
try
{
- _ret_var = ((ILayerConcrete)ws.Target).LogicalEnd();
+ _ret_var = ((ILayer)ws.Target).LogicalEnd();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).ResetHistory();
+ ((ILayer)ws.Target).ResetHistory();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).PopHistoryStack();
+ ((ILayer)ws.Target).PopHistoryStack();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).SetupOnFirstTouch(direction, entry);
+ ((ILayer)ws.Target).SetupOnFirstTouch(direction, entry);
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).FreezeDirtyLogic();
+ ((ILayer)ws.Target).FreezeDirtyLogic();
}
catch (Exception e)
{
try
{
- ((ILayerConcrete)ws.Target).DirtyLogicUnfreeze();
+ ((ILayer)ws.Target).DirtyLogicUnfreeze();
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).GetManagerFocus();
+ _ret_var = ((IManagerSub)ws.Target).GetManagerFocus();
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).SetManagerFocus(focus);
+ ((IManagerSub)ws.Target).SetManagerFocus(focus);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).GetRedirect();
+ _ret_var = ((IManagerSub)ws.Target).GetRedirect();
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).SetRedirect(redirect);
+ ((IManagerSub)ws.Target).SetRedirect(redirect);
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).GetBorderElements();
+ _ret_var = ((IManagerSub)ws.Target).GetBorderElements();
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).GetViewportElements(_in_viewport);
+ _ret_var = ((IManagerSub)ws.Target).GetViewportElements(_in_viewport);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).GetRoot();
+ _ret_var = ((IManagerSub)ws.Target).GetRoot();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).SetRoot(root);
+ _ret_var = ((IManagerSub)ws.Target).SetRoot(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).Move(direction);
+ _ret_var = ((IManagerSub)ws.Target).Move(direction);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).MoveRequest(direction, child, logical);
+ _ret_var = ((IManagerSub)ws.Target).MoveRequest(direction, child, logical);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).RequestSubchild(root);
+ _ret_var = ((IManagerSub)ws.Target).RequestSubchild(root);
}
catch (Exception e)
{
Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).Fetch(child);
+ _ret_var = ((IManagerSub)ws.Target).Fetch(child);
}
catch (Exception e)
{
Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
try
{
- _ret_var = ((IManagerSubConcrete)ws.Target).LogicalEnd();
+ _ret_var = ((IManagerSub)ws.Target).LogicalEnd();
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).ResetHistory();
+ ((IManagerSub)ws.Target).ResetHistory();
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).PopHistoryStack();
+ ((IManagerSub)ws.Target).PopHistoryStack();
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).SetupOnFirstTouch(direction, entry);
+ ((IManagerSub)ws.Target).SetupOnFirstTouch(direction, entry);
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).FreezeDirtyLogic();
+ ((IManagerSub)ws.Target).FreezeDirtyLogic();
}
catch (Exception e)
{
try
{
- ((IManagerSubConcrete)ws.Target).DirtyLogicUnfreeze();
+ ((IManagerSub)ws.Target).DirtyLogicUnfreeze();
}
catch (Exception e)
{
Eina.Rect _ret_var = default(Eina.Rect);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetFocusGeometry();
+ _ret_var = ((IObject)ws.Target).GetFocusGeometry();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetFocus();
+ _ret_var = ((IObject)ws.Target).GetFocus();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetFocus(focus);
+ ((IObject)ws.Target).SetFocus(focus);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetFocusManager();
+ _ret_var = ((IObject)ws.Target).GetFocusManager();
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetFocusParent();
+ _ret_var = ((IObject)ws.Target).GetFocusParent();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).GetChildFocus();
+ _ret_var = ((IObject)ws.Target).GetChildFocus();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetChildFocus(child_focus);
+ ((IObject)ws.Target).SetChildFocus(child_focus);
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetupOrder();
+ ((IObject)ws.Target).SetupOrder();
}
catch (Exception e)
{
try
{
- ((IObjectConcrete)ws.Target).SetupOrderNonRecursive();
+ ((IObject)ws.Target).SetupOrderNonRecursive();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IObjectConcrete)ws.Target).UpdateOnFocus();
+ _ret_var = ((IObject)ws.Target).UpdateOnFocus();
}
catch (Exception e)
{
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_format_mixin_get();
/// <summary>Initializes a new instance of the <see cref="IFormat"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
try
{
- ((IFormatConcrete)ws.Target).SetFormatCb(func_wrapper.ManagedCb);
+ ((IFormat)ws.Target).SetFormatCb(func_wrapper.ManagedCb);
}
catch (Exception e)
{
System.String _ret_var = default(System.String);
try
{
- _ret_var = ((IFormatConcrete)ws.Target).GetFormatString();
+ _ret_var = ((IFormat)ws.Target).GetFormatString();
}
catch (Exception e)
{
try
{
- ((IFormatConcrete)ws.Target).SetFormatString(units);
+ ((IFormat)ws.Target).SetFormatString(units);
}
catch (Exception e)
{
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLayoutUpdatedEvt(EventArgs e)
{
var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarSizeChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPosChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemSelectedEvt(Efl.Ui.ISelectableItemSelectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_SELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemUnselectedEvt(Efl.Ui.ISelectableItemUnselectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionPasteEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_PASTE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCopyEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_COPY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCutEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionChangedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionClearedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_i18n_interface_get();
/// <summary>Initializes a new instance of the <see cref="II18n"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImagePreloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImageResizeEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImageUnloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLoadDoneEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
{
var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_LAYOUT_EVENT_RECALC";
- AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_LAYOUT_EVENT_RECALC";
- RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnRecalcEvt(EventArgs e)
{
var key = "_EFL_LAYOUT_EVENT_RECALC";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
- AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
- RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnCircularDependencyEvt(Efl.Layout.ICalcCircularDependencyEvt_Args e)
{
var key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragEvt(Efl.Ui.IDraggableDragEvt_Args e)
{
var key = "_EFL_UI_EVENT_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragStopEvt(Efl.Ui.IDraggableDragStopEvt_Args e)
{
var key = "_EFL_UI_EVENT_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_END";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_END";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragEndEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_DRAG_END";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_START_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_START_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragStartUpEvt(Efl.Ui.IDraggableDragStartUpEvt_Args e)
{
var key = "_EFL_UI_EVENT_DRAG_START_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_START_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_START_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragStartDownEvt(Efl.Ui.IDraggableDragStartDownEvt_Args e)
{
var key = "_EFL_UI_EVENT_DRAG_START_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_START_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_START_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragStartRightEvt(Efl.Ui.IDraggableDragStartRightEvt_Args e)
{
var key = "_EFL_UI_EVENT_DRAG_START_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_DRAG_START_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_DRAG_START_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDragStartLeftEvt(Efl.Ui.IDraggableDragStartLeftEvt_Args e)
{
var key = "_EFL_UI_EVENT_DRAG_START_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarSizeChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPosChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ZOOM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ZOOM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnZoomStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_ZOOM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ZOOM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ZOOM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnZoomStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_ZOOM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ZOOM_CHANGE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ZOOM_CHANGE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnZoomChangeEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_ZOOM_CHANGE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemSelectedEvt(Efl.Ui.ISelectableItemSelectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_SELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemUnselectedEvt(Efl.Ui.ISelectableItemUnselectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionPasteEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_PASTE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCopyEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_COPY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCutEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionChangedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionClearedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_LAYOUT_EVENT_RECALC";
- AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_LAYOUT_EVENT_RECALC";
- RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnRecalcEvt(EventArgs e)
{
var key = "_EFL_LAYOUT_EVENT_RECALC";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
- AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
- RemoveNativeEventHandler(efl.Libs.Edje, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnCircularDependencyEvt(Efl.Layout.ICalcCircularDependencyEvt_Args e)
{
var key = "_EFL_LAYOUT_EVENT_CIRCULAR_DEPENDENCY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_layout_orientable_interface_get();
/// <summary>Initializes a new instance of the <see cref="ILayoutOrientable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_layout_orientable_readonly_mixin_get();
/// <summary>Initializes a new instance of the <see cref="ILayoutOrientableReadonly"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
try
{
- _ret_var = ((ILayoutOrientableReadonlyConcrete)ws.Target).GetOrientation();
+ _ret_var = ((ILayoutOrientableReadonly)ws.Target).GetOrientation();
}
catch (Exception e)
{
try
{
- ((ILayoutOrientableReadonlyConcrete)ws.Target).SetOrientation(dir);
+ ((ILayoutOrientableReadonly)ws.Target).SetOrientation(dir);
}
catch (Exception e)
{
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// <summary>Real part property</summary>
/// <param name="layout">Real part object</param>
/// <param name="part">Real part name</param>
- virtual public void SetRealPart(Efl.Object layout, System.String part) {
+ virtual protected void SetRealPart(Efl.Object layout, System.String part) {
Efl.Ui.LayoutPartBox.NativeMethods.efl_ui_layout_part_box_real_part_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),layout, part);
Eina.Error.RaiseIfUnhandledException();
}
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// <summary>Real part property</summary>
/// <param name="layout">Real part object</param>
/// <param name="part">Real part name</param>
- virtual public void SetRealPart(Efl.Object layout, System.String part) {
+ virtual protected void SetRealPart(Efl.Object layout, System.String part) {
Efl.Ui.LayoutPartTable.NativeMethods.efl_ui_layout_part_table_real_part_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),layout, part);
Eina.Error.RaiseIfUnhandledException();
}
};
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLayoutUpdatedEvt(EventArgs e)
{
var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarSizeChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPosChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemSelectedEvt(Efl.Ui.ISelectableItemSelectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_SELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemUnselectedEvt(Efl.Ui.ISelectableItemUnselectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionPasteEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_PASTE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCopyEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_COPY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCutEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionChangedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionClearedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarSizeChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPosChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemSelectedEvt(Efl.Ui.ISelectableItemSelectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_SELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemUnselectedEvt(Efl.Ui.ISelectableItemUnselectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionPasteEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_PASTE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCopyEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_COPY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCutEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionChangedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionClearedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_multi_selectable_interface_get();
/// <summary>Initializes a new instance of the <see cref="IMultiSelectable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnVisibilityChangedEvt(Efl.Gfx.IEntityVisibilityChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnPositionChangedEvt(Efl.Gfx.IEntityPositionChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_POSITION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSizeChangedEvt(Efl.Gfx.IEntitySizeChangedEvt_Args e)
{
var key = "_EFL_GFX_ENTITY_EVENT_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Activate widget</summary>
- virtual public void Activate() {
+ virtual protected void Activate() {
Efl.Ui.Nstate.NativeMethods.efl_ui_nstate_activate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
}
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void GetRangeMinMax(out double min, out double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
+ virtual public void GetRangeLimits(out double min, out double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Set the minimum and maximum values for given range widget.
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void SetRangeMinMax(double min, double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
+ virtual public void SetRangeLimits(double min, double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Control whether a given progress bar widget is at "pulsing mode" or not.
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
}
- if (efl_ui_range_min_max_get_static_delegate == null)
+ if (efl_ui_range_limits_get_static_delegate == null)
{
- efl_ui_range_min_max_get_static_delegate = new efl_ui_range_min_max_get_delegate(range_min_max_get);
+ efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
}
- if (efl_ui_range_min_max_set_static_delegate == null)
+ if (efl_ui_range_limits_set_static_delegate == null)
{
- efl_ui_range_min_max_set_static_delegate = new efl_ui_range_min_max_set_delegate(range_min_max_set);
+ efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
}
descs.AddRange(base.GetEoOps(type));
private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
- private delegate void efl_ui_range_min_max_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
+ private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
- public delegate void efl_ui_range_min_max_get_api_delegate(System.IntPtr obj, out double min, out double max);
+ public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj, out double min, out double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate> efl_ui_range_min_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate>(Module, "efl_ui_range_min_max_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
- private static void range_min_max_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
+ private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_get was called");
+ Eina.Log.Debug("function efl_ui_range_limits_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
min = default(double); max = default(double);
try
{
- ((Progressbar)ws.Target).GetRangeMinMax(out min, out max);
+ ((Progressbar)ws.Target).GetRangeLimits(out min, out max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
+ efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
}
}
- private static efl_ui_range_min_max_get_delegate efl_ui_range_min_max_get_static_delegate;
+ private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
- private delegate void efl_ui_range_min_max_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
+ private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
- public delegate void efl_ui_range_min_max_set_api_delegate(System.IntPtr obj, double min, double max);
+ public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj, double min, double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate> efl_ui_range_min_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate>(Module, "efl_ui_range_min_max_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
- private static void range_min_max_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
+ private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_set was called");
+ Eina.Log.Debug("function efl_ui_range_limits_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((Progressbar)ws.Target).SetRangeMinMax(min, max);
+ ((Progressbar)ws.Target).SetRangeLimits(min, max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
+ efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
}
}
- private static efl_ui_range_min_max_set_delegate efl_ui_range_min_max_set_static_delegate;
+ private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
#pragma warning restore CA1707, CS1591, SA1300, SA1600
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void GetRangeMinMax(out double min, out double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
+ virtual public void GetRangeLimits(out double min, out double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Set the minimum and maximum values for given range widget.
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void SetRangeMinMax(double min, double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
+ virtual public void SetRangeLimits(double min, double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Control the range value (in percentage) on a given range widget
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
}
- if (efl_ui_range_min_max_get_static_delegate == null)
+ if (efl_ui_range_limits_get_static_delegate == null)
{
- efl_ui_range_min_max_get_static_delegate = new efl_ui_range_min_max_get_delegate(range_min_max_get);
+ efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
}
- if (efl_ui_range_min_max_set_static_delegate == null)
+ if (efl_ui_range_limits_set_static_delegate == null)
{
- efl_ui_range_min_max_set_static_delegate = new efl_ui_range_min_max_set_delegate(range_min_max_set);
+ efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
}
descs.AddRange(base.GetEoOps(type));
private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
- private delegate void efl_ui_range_min_max_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
+ private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
- public delegate void efl_ui_range_min_max_get_api_delegate(System.IntPtr obj, out double min, out double max);
+ public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj, out double min, out double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate> efl_ui_range_min_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate>(Module, "efl_ui_range_min_max_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
- private static void range_min_max_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
+ private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_get was called");
+ Eina.Log.Debug("function efl_ui_range_limits_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
min = default(double); max = default(double);
try
{
- ((ProgressbarPart)ws.Target).GetRangeMinMax(out min, out max);
+ ((ProgressbarPart)ws.Target).GetRangeLimits(out min, out max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
+ efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
}
}
- private static efl_ui_range_min_max_get_delegate efl_ui_range_min_max_get_static_delegate;
+ private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
- private delegate void efl_ui_range_min_max_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
+ private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
- public delegate void efl_ui_range_min_max_set_api_delegate(System.IntPtr obj, double min, double max);
+ public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj, double min, double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate> efl_ui_range_min_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate>(Module, "efl_ui_range_min_max_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
- private static void range_min_max_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
+ private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_set was called");
+ Eina.Log.Debug("function efl_ui_range_limits_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((ProgressbarPart)ws.Target).SetRangeMinMax(min, max);
+ ((ProgressbarPart)ws.Target).SetRangeLimits(min, max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
+ efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
}
}
- private static efl_ui_range_min_max_set_delegate efl_ui_range_min_max_set_static_delegate;
+ private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
#pragma warning restore CA1707, CS1591, SA1300, SA1600
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_property_bind_interface_get();
/// <summary>Initializes a new instance of the <see cref="IPropertyBind"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
namespace Ui {
-/// <summary>Elementary radio class</summary>
+/// <summary>Elementary radio button class.
+/// Radio buttons are like check boxes in that they can be either checked or unchecked. However, radio buttons are always bunched together in groups, and only one button in each group can be checked at any given time. Pressing a different button in the group will automatically uncheck any previously checked button.
+///
+/// They are a common way to allow a user to select one option among a list.
+///
+/// To handle button grouping, you can either use an <see cref="Efl.Ui.RadioGroupImpl"/> object or use more convenient widgets like <see cref="Efl.Ui.RadioBox"/>.</summary>
[Efl.Ui.Radio.NativeMethods]
public class Radio : Efl.Ui.Check
{
{
}
- /// <summary>Get the integer value that this radio object represents.
- /// This gets the value of the radio.</summary>
- /// <returns>The value to use if this radio object is selected.</returns>
+ /// <summary>Integer value that this radio button represents.
+ /// Each radio button in a group must have a unique value. The selected button in a group can then be set or retrieved through the <see cref="Efl.Ui.IRadioGroup.SelectedValue"/> property. This value is also informed through the <see cref="Efl.Ui.IRadioGroup.ValueChangedEvt"/> event.
+ ///
+ /// All non-negative values are legal but keep in mind that 0 is the starting value for all new groups: If no button in the group has this value, then no button in the group is initially selected. -1 is the value that <see cref="Efl.Ui.IRadioGroup.SelectedValue"/> returns when no button is selected and therefore cannot be used.</summary>
+ /// <returns>The value to use when this radio button is selected. Any value can be used but 0 and -1 have special meanings as described above.</returns>
virtual public int GetStateValue() {
var _ret_var = Efl.Ui.Radio.NativeMethods.efl_ui_radio_state_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
}
- /// <summary>Set the integer value that this radio object represents.
- /// This sets the value of the radio.</summary>
- /// <param name="value">The value to use if this radio object is selected.</param>
+ /// <summary>Integer value that this radio button represents.
+ /// Each radio button in a group must have a unique value. The selected button in a group can then be set or retrieved through the <see cref="Efl.Ui.IRadioGroup.SelectedValue"/> property. This value is also informed through the <see cref="Efl.Ui.IRadioGroup.ValueChangedEvt"/> event.
+ ///
+ /// All non-negative values are legal but keep in mind that 0 is the starting value for all new groups: If no button in the group has this value, then no button in the group is initially selected. -1 is the value that <see cref="Efl.Ui.IRadioGroup.SelectedValue"/> returns when no button is selected and therefore cannot be used.</summary>
+ /// <param name="value">The value to use when this radio button is selected. Any value can be used but 0 and -1 have special meanings as described above.</param>
virtual public void SetStateValue(int value) {
Efl.Ui.Radio.NativeMethods.efl_ui_radio_state_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
Eina.Error.RaiseIfUnhandledException();
}
- /// <summary>Set a convenience pointer to an integer, which changes when radio group value changes.
- /// This sets a pointer to an integer that in addition to the radio object state will also be modified directly. To stop setting the object pointed to, simply use NULL as the valuep argument. If valuep is not NULL then when called, the radio object state will also be modified to reflect the value of the integer valuep points to, just like calling elm_radio_value_set().</summary>
- /// <param name="valuep">Pointer to the integer to modify</param>
- virtual public void SetValuePointer(int valuep) {
- var _in_valuep = Eina.PrimitiveConversion.ManagedToPointerAlloc(valuep);
- Efl.Ui.Radio.NativeMethods.efl_ui_radio_value_pointer_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_valuep);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Get the selected radio object.</summary>
- /// <returns>The selected radio object</returns>
- virtual public Efl.Canvas.Object GetSelectedObject() {
- var _ret_var = Efl.Ui.Radio.NativeMethods.efl_ui_radio_selected_object_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Change the value of the group.
- /// This will enable the radio button in the group that is assosiated with this value. A value which is not assosiated with any radio button will result in every radio button beeing disabled.</summary>
- /// <returns>The value of the radio button in the group which should be enabled.</returns>
- virtual public int GetGroupValue() {
- var _ret_var = Efl.Ui.Radio.NativeMethods.efl_ui_radio_group_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Change the value of the group.
- /// This will enable the radio button in the group that is assosiated with this value. A value which is not assosiated with any radio button will result in every radio button beeing disabled.</summary>
- /// <param name="value">The value of the radio button in the group which should be enabled.</param>
- virtual public void SetGroupValue(int value) {
- Efl.Ui.Radio.NativeMethods.efl_ui_radio_group_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Add this radio to a group of other radio objects
- /// Radio objects work in groups. Each member should have a different integer value assigned. In order to have them work as a group, they need to know about each other. This adds the given radio object to the group of which the group object indicated is a member.</summary>
- /// <param name="group">Any radio object whose group the obj is to join.</param>
- virtual public void AddGroup(Efl.Ui.Radio group) {
- Efl.Ui.Radio.NativeMethods.efl_ui_radio_group_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),group);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Get the integer value that this radio object represents.
- /// This gets the value of the radio.</summary>
- /// <value>The value to use if this radio object is selected.</value>
+ /// <summary>Integer value that this radio button represents.
+ /// Each radio button in a group must have a unique value. The selected button in a group can then be set or retrieved through the <see cref="Efl.Ui.IRadioGroup.SelectedValue"/> property. This value is also informed through the <see cref="Efl.Ui.IRadioGroup.ValueChangedEvt"/> event.
+ ///
+ /// All non-negative values are legal but keep in mind that 0 is the starting value for all new groups: If no button in the group has this value, then no button in the group is initially selected. -1 is the value that <see cref="Efl.Ui.IRadioGroup.SelectedValue"/> returns when no button is selected and therefore cannot be used.</summary>
+ /// <value>The value to use when this radio button is selected. Any value can be used but 0 and -1 have special meanings as described above.</value>
public int StateValue {
get { return GetStateValue(); }
set { SetStateValue(value); }
}
- /// <summary>Set a convenience pointer to an integer, which changes when radio group value changes.
- /// This sets a pointer to an integer that in addition to the radio object state will also be modified directly. To stop setting the object pointed to, simply use NULL as the valuep argument. If valuep is not NULL then when called, the radio object state will also be modified to reflect the value of the integer valuep points to, just like calling elm_radio_value_set().</summary>
- /// <value>Pointer to the integer to modify</value>
- public int ValuePointer {
- set { SetValuePointer(value); }
- }
- /// <summary>Get the selected radio object.</summary>
- /// <value>The selected radio object</value>
- public Efl.Canvas.Object SelectedObject {
- get { return GetSelectedObject(); }
- }
- /// <summary>Change the value of the group.
- /// This will enable the radio button in the group that is assosiated with this value. A value which is not assosiated with any radio button will result in every radio button beeing disabled.</summary>
- /// <value>The value of the radio button in the group which should be enabled.</value>
- public int GroupValue {
- get { return GetGroupValue(); }
- set { SetGroupValue(value); }
- }
private static IntPtr GetEflClassStatic()
{
return Efl.Ui.Radio.efl_ui_radio_class_get();
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_state_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_state_value_set_static_delegate) });
}
- if (efl_ui_radio_value_pointer_set_static_delegate == null)
- {
- efl_ui_radio_value_pointer_set_static_delegate = new efl_ui_radio_value_pointer_set_delegate(value_pointer_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetValuePointer") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_value_pointer_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_value_pointer_set_static_delegate) });
- }
-
- if (efl_ui_radio_selected_object_get_static_delegate == null)
- {
- efl_ui_radio_selected_object_get_static_delegate = new efl_ui_radio_selected_object_get_delegate(selected_object_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetSelectedObject") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_selected_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_selected_object_get_static_delegate) });
- }
-
- if (efl_ui_radio_group_value_get_static_delegate == null)
- {
- efl_ui_radio_group_value_get_static_delegate = new efl_ui_radio_group_value_get_delegate(group_value_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetGroupValue") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_value_get_static_delegate) });
- }
-
- if (efl_ui_radio_group_value_set_static_delegate == null)
- {
- efl_ui_radio_group_value_set_static_delegate = new efl_ui_radio_group_value_set_delegate(group_value_set);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "SetGroupValue") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_value_set_static_delegate) });
- }
-
- if (efl_ui_radio_group_add_static_delegate == null)
- {
- efl_ui_radio_group_add_static_delegate = new efl_ui_radio_group_add_delegate(group_add);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "AddGroup") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_add"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_add_static_delegate) });
- }
-
descs.AddRange(base.GetEoOps(type));
return descs;
}
private static efl_ui_radio_state_value_set_delegate efl_ui_radio_state_value_set_static_delegate;
-
- private delegate void efl_ui_radio_value_pointer_set_delegate(System.IntPtr obj, System.IntPtr pd, System.IntPtr valuep);
-
-
- public delegate void efl_ui_radio_value_pointer_set_api_delegate(System.IntPtr obj, System.IntPtr valuep);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_radio_value_pointer_set_api_delegate> efl_ui_radio_value_pointer_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_value_pointer_set_api_delegate>(Module, "efl_ui_radio_value_pointer_set");
-
- private static void value_pointer_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr valuep)
- {
- Eina.Log.Debug("function efl_ui_radio_value_pointer_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- var _in_valuep = Eina.PrimitiveConversion.PointerToManaged<int>(valuep);
-
- try
- {
- ((Radio)ws.Target).SetValuePointer(_in_valuep);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_radio_value_pointer_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), valuep);
- }
- }
-
- private static efl_ui_radio_value_pointer_set_delegate efl_ui_radio_value_pointer_set_static_delegate;
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- private delegate Efl.Canvas.Object efl_ui_radio_selected_object_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- public delegate Efl.Canvas.Object efl_ui_radio_selected_object_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_radio_selected_object_get_api_delegate> efl_ui_radio_selected_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_selected_object_get_api_delegate>(Module, "efl_ui_radio_selected_object_get");
-
- private static Efl.Canvas.Object selected_object_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_ui_radio_selected_object_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
- try
- {
- _ret_var = ((Radio)ws.Target).GetSelectedObject();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_ui_radio_selected_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_ui_radio_selected_object_get_delegate efl_ui_radio_selected_object_get_static_delegate;
-
-
- private delegate int efl_ui_radio_group_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
-
-
- public delegate int efl_ui_radio_group_value_get_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_value_get_api_delegate> efl_ui_radio_group_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_value_get_api_delegate>(Module, "efl_ui_radio_group_value_get");
-
- private static int group_value_get(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_ui_radio_group_value_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- int _ret_var = default(int);
- try
- {
- _ret_var = ((Radio)ws.Target).GetGroupValue();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_ui_radio_group_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_ui_radio_group_value_get_delegate efl_ui_radio_group_value_get_static_delegate;
-
-
- private delegate void efl_ui_radio_group_value_set_delegate(System.IntPtr obj, System.IntPtr pd, int value);
-
-
- public delegate void efl_ui_radio_group_value_set_api_delegate(System.IntPtr obj, int value);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_value_set_api_delegate> efl_ui_radio_group_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_value_set_api_delegate>(Module, "efl_ui_radio_group_value_set");
-
- private static void group_value_set(System.IntPtr obj, System.IntPtr pd, int value)
- {
- Eina.Log.Debug("function efl_ui_radio_group_value_set was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Radio)ws.Target).SetGroupValue(value);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_radio_group_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
- }
- }
-
- private static efl_ui_radio_group_value_set_delegate efl_ui_radio_group_value_set_static_delegate;
-
-
- private delegate void efl_ui_radio_group_add_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio group);
-
-
- public delegate void efl_ui_radio_group_add_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio group);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_add_api_delegate> efl_ui_radio_group_add_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_add_api_delegate>(Module, "efl_ui_radio_group_add");
-
- private static void group_add(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio group)
- {
- Eina.Log.Debug("function efl_ui_radio_group_add was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Radio)ws.Target).AddGroup(group);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_radio_group_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), group);
- }
- }
-
- private static efl_ui_radio_group_add_delegate efl_ui_radio_group_add_static_delegate;
-
#pragma warning restore CA1707, CS1591, SA1300, SA1600
}
--- /dev/null
+#pragma warning disable CS1591
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.ComponentModel;
+namespace Efl {
+
+namespace Ui {
+
+/// <summary>A standard <see cref="Efl.Ui.Box"/> container which automatically handles grouping of any <see cref="Efl.Ui.Radio"/> widget added to it.
+/// All <see cref="Efl.Ui.Radio"/> widgets are added to the same internal group which you only indirectly access through this object.</summary>
+[Efl.Ui.RadioBox.NativeMethods]
+public class RadioBox : Efl.Ui.Box, Efl.Ui.IRadioGroup
+{
+ ///<summary>Pointer to the native class description.</summary>
+ public override System.IntPtr NativeClass
+ {
+ get
+ {
+ if (((object)this).GetType() == typeof(RadioBox))
+ {
+ return GetEflClassStatic();
+ }
+ else
+ {
+ return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
+ }
+ }
+ }
+
+ [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
+ efl_ui_radio_box_class_get();
+ /// <summary>Initializes a new instance of the <see cref="RadioBox"/> class.</summary>
+ /// <param name="parent">Parent instance.</param>
+ /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
+ public RadioBox(Efl.Object parent
+ , System.String style = null) : base(efl_ui_radio_box_class_get(), typeof(RadioBox), parent)
+ {
+ if (Efl.Eo.Globals.ParamHelperCheck(style))
+ {
+ SetStyle(Efl.Eo.Globals.GetParamHelper(style));
+ }
+
+ FinishInstantiation();
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="RadioBox"/> class.
+ /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
+ /// <param name="raw">The native pointer to be wrapped.</param>
+ protected RadioBox(System.IntPtr raw) : base(raw)
+ {
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="RadioBox"/> class.
+ /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
+ /// <param name="baseKlass">The pointer to the base native Eo class.</param>
+ /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
+ /// <param name="parent">The Efl.Object parent of this instance.</param>
+ protected RadioBox(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
+ {
+ }
+
+ /// <summary>Emitted each time the <c>selected_value</c> changes. The event information contains the <see cref="Efl.Ui.Radio.StateValue"/> of the newly selected button or -1 if no button is now selected.</summary>
+ public event EventHandler<Efl.Ui.IRadioGroupValueChangedEvt_Args> ValueChangedEvt
+ {
+ add
+ {
+ lock (eventLock)
+ {
+ Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
+ {
+ var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
+ if (obj != null)
+ {
+ Efl.Ui.IRadioGroupValueChangedEvt_Args args = new Efl.Ui.IRadioGroupValueChangedEvt_Args();
+ args.arg = Marshal.ReadInt32(evt.Info);
+ try
+ {
+ value?.Invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Error(e.ToString());
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+ }
+ };
+
+ string key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
+ }
+ }
+
+ remove
+ {
+ lock (eventLock)
+ {
+ string key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
+ }
+ }
+ }
+ ///<summary>Method to raise event ValueChangedEvt.</summary>
+ public void OnValueChangedEvt(Efl.Ui.IRadioGroupValueChangedEvt_Args e)
+ {
+ var key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
+ if (desc == IntPtr.Zero)
+ {
+ Eina.Log.Error($"Failed to get native event {key}");
+ return;
+ }
+
+ IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
+ try
+ {
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ }
+ finally
+ {
+ Marshal.FreeHGlobal(info);
+ }
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <returns>The currently selected radio button in the group, or <c>NULL</c>.</returns>
+ virtual public Efl.Ui.Radio GetSelectedObject() {
+ var _ret_var = Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_object_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <param name="selected_object">The currently selected radio button in the group, or <c>NULL</c>.</param>
+ virtual public void SetSelectedObject(Efl.Ui.Radio selected_object) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_object_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),selected_object);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <returns>The value of the currently selected radio button, or -1.</returns>
+ virtual public int GetSelectedValue() {
+ var _ret_var = Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <param name="selected_value">The value of the currently selected radio button, or -1.</param>
+ virtual public void SetSelectedValue(int selected_value) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),selected_value);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Register a new <see cref="Efl.Ui.Radio"/> button to this group. Keep in mind that registering to a group will only handle button grouping, you still need to add the button to a layout for it to be rendered.
+ /// If the <see cref="Efl.Ui.Radio.StateValue"/> of the new button is already used by a previous button in the group, the button will not be added.
+ ///
+ /// See also <see cref="Efl.Ui.IRadioGroup.Unregister"/>.</summary>
+ /// <param name="radio">The radio button to add to the group.</param>
+ virtual public void Register(Efl.Ui.Radio radio) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_register_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),radio);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Unregister an <see cref="Efl.Ui.Radio"/> button from this group. This will unlink the behavior of this button from the other buttons in the group, but if it still belongs to a layout, it will still be rendered.
+ /// If the button was not registered in the group the call is ignored. If the button was selected, no button will be selected in the group after this call.
+ ///
+ /// See also <see cref="Efl.Ui.IRadioGroup.Register"/>.</summary>
+ /// <param name="radio">The radio button to remove from the group.</param>
+ virtual public void Unregister(Efl.Ui.Radio radio) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_unregister_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),radio);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <value>The currently selected radio button in the group, or <c>NULL</c>.</value>
+ public Efl.Ui.Radio SelectedObject {
+ get { return GetSelectedObject(); }
+ set { SetSelectedObject(value); }
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <value>The value of the currently selected radio button, or -1.</value>
+ public int SelectedValue {
+ get { return GetSelectedValue(); }
+ set { SetSelectedValue(value); }
+ }
+ private static IntPtr GetEflClassStatic()
+ {
+ return Efl.Ui.RadioBox.efl_ui_radio_box_class_get();
+ }
+ /// <summary>Wrapper for native methods and virtual method delegates.
+ /// For internal use by generated code only.</summary>
+ public new class NativeMethods : Efl.Ui.Box.NativeMethods
+ {
+ private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Elementary);
+ /// <summary>Gets the list of Eo operations to override.</summary>
+ /// <returns>The list of Eo operations to be overload.</returns>
+ public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
+ {
+ var descs = new System.Collections.Generic.List<Efl_Op_Description>();
+ var methods = Efl.Eo.Globals.GetUserMethods(type);
+
+ if (efl_ui_radio_group_selected_object_get_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_object_get_static_delegate = new efl_ui_radio_group_selected_object_get_delegate(selected_object_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetSelectedObject") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_object_get_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_object_set_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_object_set_static_delegate = new efl_ui_radio_group_selected_object_set_delegate(selected_object_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetSelectedObject") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_object_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_object_set_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_value_get_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_value_get_static_delegate = new efl_ui_radio_group_selected_value_get_delegate(selected_value_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetSelectedValue") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_value_get_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_value_set_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_value_set_static_delegate = new efl_ui_radio_group_selected_value_set_delegate(selected_value_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetSelectedValue") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_value_set_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_register_static_delegate == null)
+ {
+ efl_ui_radio_group_register_static_delegate = new efl_ui_radio_group_register_delegate(register);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Register") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_register"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_register_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_unregister_static_delegate == null)
+ {
+ efl_ui_radio_group_unregister_static_delegate = new efl_ui_radio_group_unregister_delegate(unregister);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Unregister") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_unregister"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_unregister_static_delegate) });
+ }
+
+ descs.AddRange(base.GetEoOps(type));
+ return descs;
+ }
+ /// <summary>Returns the Eo class for the native methods of this class.</summary>
+ /// <returns>The native class pointer.</returns>
+ public override IntPtr GetEflClass()
+ {
+ return Efl.Ui.RadioBox.efl_ui_radio_box_class_get();
+ }
+
+ #pragma warning disable CA1707, CS1591, SA1300, SA1600
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Ui.Radio efl_ui_radio_group_selected_object_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Ui.Radio efl_ui_radio_group_selected_object_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_get_api_delegate> efl_ui_radio_group_selected_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_get_api_delegate>(Module, "efl_ui_radio_group_selected_object_get");
+
+ private static Efl.Ui.Radio selected_object_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_object_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Ui.Radio _ret_var = default(Efl.Ui.Radio);
+ try
+ {
+ _ret_var = ((RadioBox)ws.Target).GetSelectedObject();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_radio_group_selected_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_radio_group_selected_object_get_delegate efl_ui_radio_group_selected_object_get_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_selected_object_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio selected_object);
+
+
+ public delegate void efl_ui_radio_group_selected_object_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio selected_object);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_set_api_delegate> efl_ui_radio_group_selected_object_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_set_api_delegate>(Module, "efl_ui_radio_group_selected_object_set");
+
+ private static void selected_object_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio selected_object)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_object_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioBox)ws.Target).SetSelectedObject(selected_object);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_selected_object_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_object);
+ }
+ }
+
+ private static efl_ui_radio_group_selected_object_set_delegate efl_ui_radio_group_selected_object_set_static_delegate;
+
+
+ private delegate int efl_ui_radio_group_selected_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate int efl_ui_radio_group_selected_value_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_get_api_delegate> efl_ui_radio_group_selected_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_get_api_delegate>(Module, "efl_ui_radio_group_selected_value_get");
+
+ private static int selected_value_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_value_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((RadioBox)ws.Target).GetSelectedValue();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_radio_group_selected_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_radio_group_selected_value_get_delegate efl_ui_radio_group_selected_value_get_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_selected_value_set_delegate(System.IntPtr obj, System.IntPtr pd, int selected_value);
+
+
+ public delegate void efl_ui_radio_group_selected_value_set_api_delegate(System.IntPtr obj, int selected_value);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_set_api_delegate> efl_ui_radio_group_selected_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_set_api_delegate>(Module, "efl_ui_radio_group_selected_value_set");
+
+ private static void selected_value_set(System.IntPtr obj, System.IntPtr pd, int selected_value)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_value_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioBox)ws.Target).SetSelectedValue(selected_value);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_selected_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_value);
+ }
+ }
+
+ private static efl_ui_radio_group_selected_value_set_delegate efl_ui_radio_group_selected_value_set_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_register_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+
+ public delegate void efl_ui_radio_group_register_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_register_api_delegate> efl_ui_radio_group_register_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_register_api_delegate>(Module, "efl_ui_radio_group_register");
+
+ private static void register(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio radio)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_register was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioBox)ws.Target).Register(radio);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_register_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radio);
+ }
+ }
+
+ private static efl_ui_radio_group_register_delegate efl_ui_radio_group_register_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_unregister_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+
+ public delegate void efl_ui_radio_group_unregister_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_unregister_api_delegate> efl_ui_radio_group_unregister_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_unregister_api_delegate>(Module, "efl_ui_radio_group_unregister");
+
+ private static void unregister(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio radio)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_unregister was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioBox)ws.Target).Unregister(radio);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_unregister_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radio);
+ }
+ }
+
+ private static efl_ui_radio_group_unregister_delegate efl_ui_radio_group_unregister_static_delegate;
+
+ #pragma warning restore CA1707, CS1591, SA1300, SA1600
+
+}
+}
+}
+
+}
+
--- /dev/null
+#pragma warning disable CS1591
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.ComponentModel;
+namespace Efl {
+
+namespace Ui {
+
+/// <summary>Interface for manually handling a group of <see cref="Efl.Ui.Radio"/> buttons.
+/// See the documentation of <see cref="Efl.Ui.Radio"/> for an explanation of radio button grouping.</summary>
+[Efl.Ui.IRadioGroupConcrete.NativeMethods]
+public interface IRadioGroup :
+ Efl.Eo.IWrapper, IDisposable
+{
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+/// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+/// <returns>The currently selected radio button in the group, or <c>NULL</c>.</returns>
+Efl.Ui.Radio GetSelectedObject();
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+/// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+/// <param name="selected_object">The currently selected radio button in the group, or <c>NULL</c>.</param>
+void SetSelectedObject(Efl.Ui.Radio selected_object);
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+/// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+/// <returns>The value of the currently selected radio button, or -1.</returns>
+int GetSelectedValue();
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+/// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+/// <param name="selected_value">The value of the currently selected radio button, or -1.</param>
+void SetSelectedValue(int selected_value);
+ /// <summary>Register a new <see cref="Efl.Ui.Radio"/> button to this group. Keep in mind that registering to a group will only handle button grouping, you still need to add the button to a layout for it to be rendered.
+/// If the <see cref="Efl.Ui.Radio.StateValue"/> of the new button is already used by a previous button in the group, the button will not be added.
+///
+/// See also <see cref="Efl.Ui.IRadioGroup.Unregister"/>.</summary>
+/// <param name="radio">The radio button to add to the group.</param>
+void Register(Efl.Ui.Radio radio);
+ /// <summary>Unregister an <see cref="Efl.Ui.Radio"/> button from this group. This will unlink the behavior of this button from the other buttons in the group, but if it still belongs to a layout, it will still be rendered.
+/// If the button was not registered in the group the call is ignored. If the button was selected, no button will be selected in the group after this call.
+///
+/// See also <see cref="Efl.Ui.IRadioGroup.Register"/>.</summary>
+/// <param name="radio">The radio button to remove from the group.</param>
+void Unregister(Efl.Ui.Radio radio);
+ /// <summary>Emitted each time the <c>selected_value</c> changes. The event information contains the <see cref="Efl.Ui.Radio.StateValue"/> of the newly selected button or -1 if no button is now selected.</summary>
+ event EventHandler<Efl.Ui.IRadioGroupValueChangedEvt_Args> ValueChangedEvt;
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <value>The currently selected radio button in the group, or <c>NULL</c>.</value>
+ Efl.Ui.Radio SelectedObject {
+ get ;
+ set ;
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <value>The value of the currently selected radio button, or -1.</value>
+ int SelectedValue {
+ get ;
+ set ;
+ }
+}
+///<summary>Event argument wrapper for event <see cref="Efl.Ui.IRadioGroup.ValueChangedEvt"/>.</summary>
+public class IRadioGroupValueChangedEvt_Args : EventArgs {
+ ///<summary>Actual event payload.</summary>
+ public int arg { get; set; }
+}
+/// <summary>Interface for manually handling a group of <see cref="Efl.Ui.Radio"/> buttons.
+/// See the documentation of <see cref="Efl.Ui.Radio"/> for an explanation of radio button grouping.</summary>
+sealed public class IRadioGroupConcrete :
+ Efl.Eo.EoWrapper
+ , IRadioGroup
+
+{
+ ///<summary>Pointer to the native class description.</summary>
+ public override System.IntPtr NativeClass
+ {
+ get
+ {
+ if (((object)this).GetType() == typeof(IRadioGroupConcrete))
+ {
+ return GetEflClassStatic();
+ }
+ else
+ {
+ return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
+ }
+ }
+ }
+
+ [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
+ efl_ui_radio_group_interface_get();
+ /// <summary>Initializes a new instance of the <see cref="IRadioGroup"/> class.
+ /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
+ private IRadioGroupConcrete(System.IntPtr raw) : base(raw)
+ {
+ }
+
+ /// <summary>Emitted each time the <c>selected_value</c> changes. The event information contains the <see cref="Efl.Ui.Radio.StateValue"/> of the newly selected button or -1 if no button is now selected.</summary>
+ public event EventHandler<Efl.Ui.IRadioGroupValueChangedEvt_Args> ValueChangedEvt
+ {
+ add
+ {
+ lock (eventLock)
+ {
+ Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
+ {
+ var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
+ if (obj != null)
+ {
+ Efl.Ui.IRadioGroupValueChangedEvt_Args args = new Efl.Ui.IRadioGroupValueChangedEvt_Args();
+ args.arg = Marshal.ReadInt32(evt.Info);
+ try
+ {
+ value?.Invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Error(e.ToString());
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+ }
+ };
+
+ string key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
+ }
+ }
+
+ remove
+ {
+ lock (eventLock)
+ {
+ string key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
+ }
+ }
+ }
+ ///<summary>Method to raise event ValueChangedEvt.</summary>
+ public void OnValueChangedEvt(Efl.Ui.IRadioGroupValueChangedEvt_Args e)
+ {
+ var key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
+ if (desc == IntPtr.Zero)
+ {
+ Eina.Log.Error($"Failed to get native event {key}");
+ return;
+ }
+
+ IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
+ try
+ {
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ }
+ finally
+ {
+ Marshal.FreeHGlobal(info);
+ }
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <returns>The currently selected radio button in the group, or <c>NULL</c>.</returns>
+ public Efl.Ui.Radio GetSelectedObject() {
+ var _ret_var = Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_object_get_ptr.Value.Delegate(this.NativeHandle);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <param name="selected_object">The currently selected radio button in the group, or <c>NULL</c>.</param>
+ public void SetSelectedObject(Efl.Ui.Radio selected_object) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_object_set_ptr.Value.Delegate(this.NativeHandle,selected_object);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <returns>The value of the currently selected radio button, or -1.</returns>
+ public int GetSelectedValue() {
+ var _ret_var = Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_value_get_ptr.Value.Delegate(this.NativeHandle);
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <param name="selected_value">The value of the currently selected radio button, or -1.</param>
+ public void SetSelectedValue(int selected_value) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_value_set_ptr.Value.Delegate(this.NativeHandle,selected_value);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Register a new <see cref="Efl.Ui.Radio"/> button to this group. Keep in mind that registering to a group will only handle button grouping, you still need to add the button to a layout for it to be rendered.
+ /// If the <see cref="Efl.Ui.Radio.StateValue"/> of the new button is already used by a previous button in the group, the button will not be added.
+ ///
+ /// See also <see cref="Efl.Ui.IRadioGroup.Unregister"/>.</summary>
+ /// <param name="radio">The radio button to add to the group.</param>
+ public void Register(Efl.Ui.Radio radio) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_register_ptr.Value.Delegate(this.NativeHandle,radio);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Unregister an <see cref="Efl.Ui.Radio"/> button from this group. This will unlink the behavior of this button from the other buttons in the group, but if it still belongs to a layout, it will still be rendered.
+ /// If the button was not registered in the group the call is ignored. If the button was selected, no button will be selected in the group after this call.
+ ///
+ /// See also <see cref="Efl.Ui.IRadioGroup.Register"/>.</summary>
+ /// <param name="radio">The radio button to remove from the group.</param>
+ public void Unregister(Efl.Ui.Radio radio) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_unregister_ptr.Value.Delegate(this.NativeHandle,radio);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <value>The currently selected radio button in the group, or <c>NULL</c>.</value>
+ public Efl.Ui.Radio SelectedObject {
+ get { return GetSelectedObject(); }
+ set { SetSelectedObject(value); }
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <value>The value of the currently selected radio button, or -1.</value>
+ public int SelectedValue {
+ get { return GetSelectedValue(); }
+ set { SetSelectedValue(value); }
+ }
+ private static IntPtr GetEflClassStatic()
+ {
+ return Efl.Ui.IRadioGroupConcrete.efl_ui_radio_group_interface_get();
+ }
+ /// <summary>Wrapper for native methods and virtual method delegates.
+ /// For internal use by generated code only.</summary>
+ public class NativeMethods : Efl.Eo.NativeClass
+ {
+ private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Elementary);
+ /// <summary>Gets the list of Eo operations to override.</summary>
+ /// <returns>The list of Eo operations to be overload.</returns>
+ public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
+ {
+ var descs = new System.Collections.Generic.List<Efl_Op_Description>();
+ var methods = Efl.Eo.Globals.GetUserMethods(type);
+
+ if (efl_ui_radio_group_selected_object_get_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_object_get_static_delegate = new efl_ui_radio_group_selected_object_get_delegate(selected_object_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetSelectedObject") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_object_get_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_object_set_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_object_set_static_delegate = new efl_ui_radio_group_selected_object_set_delegate(selected_object_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetSelectedObject") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_object_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_object_set_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_value_get_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_value_get_static_delegate = new efl_ui_radio_group_selected_value_get_delegate(selected_value_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetSelectedValue") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_value_get_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_value_set_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_value_set_static_delegate = new efl_ui_radio_group_selected_value_set_delegate(selected_value_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetSelectedValue") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_value_set_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_register_static_delegate == null)
+ {
+ efl_ui_radio_group_register_static_delegate = new efl_ui_radio_group_register_delegate(register);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Register") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_register"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_register_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_unregister_static_delegate == null)
+ {
+ efl_ui_radio_group_unregister_static_delegate = new efl_ui_radio_group_unregister_delegate(unregister);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Unregister") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_unregister"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_unregister_static_delegate) });
+ }
+
+ return descs;
+ }
+ /// <summary>Returns the Eo class for the native methods of this class.</summary>
+ /// <returns>The native class pointer.</returns>
+ public override IntPtr GetEflClass()
+ {
+ return Efl.Ui.IRadioGroupConcrete.efl_ui_radio_group_interface_get();
+ }
+
+ #pragma warning disable CA1707, CS1591, SA1300, SA1600
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Ui.Radio efl_ui_radio_group_selected_object_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Ui.Radio efl_ui_radio_group_selected_object_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_get_api_delegate> efl_ui_radio_group_selected_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_get_api_delegate>(Module, "efl_ui_radio_group_selected_object_get");
+
+ private static Efl.Ui.Radio selected_object_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_object_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Ui.Radio _ret_var = default(Efl.Ui.Radio);
+ try
+ {
+ _ret_var = ((IRadioGroup)ws.Target).GetSelectedObject();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_radio_group_selected_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_radio_group_selected_object_get_delegate efl_ui_radio_group_selected_object_get_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_selected_object_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio selected_object);
+
+
+ public delegate void efl_ui_radio_group_selected_object_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio selected_object);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_set_api_delegate> efl_ui_radio_group_selected_object_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_set_api_delegate>(Module, "efl_ui_radio_group_selected_object_set");
+
+ private static void selected_object_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio selected_object)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_object_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((IRadioGroup)ws.Target).SetSelectedObject(selected_object);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_selected_object_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_object);
+ }
+ }
+
+ private static efl_ui_radio_group_selected_object_set_delegate efl_ui_radio_group_selected_object_set_static_delegate;
+
+
+ private delegate int efl_ui_radio_group_selected_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate int efl_ui_radio_group_selected_value_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_get_api_delegate> efl_ui_radio_group_selected_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_get_api_delegate>(Module, "efl_ui_radio_group_selected_value_get");
+
+ private static int selected_value_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_value_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((IRadioGroup)ws.Target).GetSelectedValue();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_radio_group_selected_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_radio_group_selected_value_get_delegate efl_ui_radio_group_selected_value_get_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_selected_value_set_delegate(System.IntPtr obj, System.IntPtr pd, int selected_value);
+
+
+ public delegate void efl_ui_radio_group_selected_value_set_api_delegate(System.IntPtr obj, int selected_value);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_set_api_delegate> efl_ui_radio_group_selected_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_set_api_delegate>(Module, "efl_ui_radio_group_selected_value_set");
+
+ private static void selected_value_set(System.IntPtr obj, System.IntPtr pd, int selected_value)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_value_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((IRadioGroup)ws.Target).SetSelectedValue(selected_value);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_selected_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_value);
+ }
+ }
+
+ private static efl_ui_radio_group_selected_value_set_delegate efl_ui_radio_group_selected_value_set_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_register_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+
+ public delegate void efl_ui_radio_group_register_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_register_api_delegate> efl_ui_radio_group_register_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_register_api_delegate>(Module, "efl_ui_radio_group_register");
+
+ private static void register(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio radio)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_register was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((IRadioGroup)ws.Target).Register(radio);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_register_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radio);
+ }
+ }
+
+ private static efl_ui_radio_group_register_delegate efl_ui_radio_group_register_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_unregister_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+
+ public delegate void efl_ui_radio_group_unregister_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_unregister_api_delegate> efl_ui_radio_group_unregister_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_unregister_api_delegate>(Module, "efl_ui_radio_group_unregister");
+
+ private static void unregister(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio radio)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_unregister was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((IRadioGroup)ws.Target).Unregister(radio);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_unregister_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radio);
+ }
+ }
+
+ private static efl_ui_radio_group_unregister_delegate efl_ui_radio_group_unregister_static_delegate;
+
+ #pragma warning restore CA1707, CS1591, SA1300, SA1600
+
+}
+}
+}
+
+}
+
--- /dev/null
+#pragma warning disable CS1591
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.ComponentModel;
+namespace Efl {
+
+namespace Ui {
+
+/// <summary>Object with the default implementation for <see cref="Efl.Ui.IRadioGroup"/>.</summary>
+[Efl.Ui.RadioGroupImpl.NativeMethods]
+public class RadioGroupImpl : Efl.Object, Efl.Ui.IRadioGroup
+{
+ ///<summary>Pointer to the native class description.</summary>
+ public override System.IntPtr NativeClass
+ {
+ get
+ {
+ if (((object)this).GetType() == typeof(RadioGroupImpl))
+ {
+ return GetEflClassStatic();
+ }
+ else
+ {
+ return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
+ }
+ }
+ }
+
+ [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
+ efl_ui_radio_group_impl_class_get();
+ /// <summary>Initializes a new instance of the <see cref="RadioGroupImpl"/> class.</summary>
+ /// <param name="parent">Parent instance.</param>
+ public RadioGroupImpl(Efl.Object parent= null
+ ) : base(efl_ui_radio_group_impl_class_get(), typeof(RadioGroupImpl), parent)
+ {
+ FinishInstantiation();
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="RadioGroupImpl"/> class.
+ /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
+ /// <param name="raw">The native pointer to be wrapped.</param>
+ protected RadioGroupImpl(System.IntPtr raw) : base(raw)
+ {
+ }
+
+ /// <summary>Initializes a new instance of the <see cref="RadioGroupImpl"/> class.
+ /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
+ /// <param name="baseKlass">The pointer to the base native Eo class.</param>
+ /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
+ /// <param name="parent">The Efl.Object parent of this instance.</param>
+ protected RadioGroupImpl(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
+ {
+ }
+
+ /// <summary>Emitted each time the <c>selected_value</c> changes. The event information contains the <see cref="Efl.Ui.Radio.StateValue"/> of the newly selected button or -1 if no button is now selected.</summary>
+ public event EventHandler<Efl.Ui.IRadioGroupValueChangedEvt_Args> ValueChangedEvt
+ {
+ add
+ {
+ lock (eventLock)
+ {
+ Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
+ {
+ var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
+ if (obj != null)
+ {
+ Efl.Ui.IRadioGroupValueChangedEvt_Args args = new Efl.Ui.IRadioGroupValueChangedEvt_Args();
+ args.arg = Marshal.ReadInt32(evt.Info);
+ try
+ {
+ value?.Invoke(obj, args);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Error(e.ToString());
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+ }
+ };
+
+ string key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
+ }
+ }
+
+ remove
+ {
+ lock (eventLock)
+ {
+ string key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
+ }
+ }
+ }
+ ///<summary>Method to raise event ValueChangedEvt.</summary>
+ public void OnValueChangedEvt(Efl.Ui.IRadioGroupValueChangedEvt_Args e)
+ {
+ var key = "_EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED";
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
+ if (desc == IntPtr.Zero)
+ {
+ Eina.Log.Error($"Failed to get native event {key}");
+ return;
+ }
+
+ IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
+ try
+ {
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ }
+ finally
+ {
+ Marshal.FreeHGlobal(info);
+ }
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <returns>The currently selected radio button in the group, or <c>NULL</c>.</returns>
+ virtual public Efl.Ui.Radio GetSelectedObject() {
+ var _ret_var = Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_object_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <param name="selected_object">The currently selected radio button in the group, or <c>NULL</c>.</param>
+ virtual public void SetSelectedObject(Efl.Ui.Radio selected_object) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_object_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),selected_object);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <returns>The value of the currently selected radio button, or -1.</returns>
+ virtual public int GetSelectedValue() {
+ var _ret_var = Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
+ Eina.Error.RaiseIfUnhandledException();
+ return _ret_var;
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <param name="selected_value">The value of the currently selected radio button, or -1.</param>
+ virtual public void SetSelectedValue(int selected_value) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_selected_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),selected_value);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Register a new <see cref="Efl.Ui.Radio"/> button to this group. Keep in mind that registering to a group will only handle button grouping, you still need to add the button to a layout for it to be rendered.
+ /// If the <see cref="Efl.Ui.Radio.StateValue"/> of the new button is already used by a previous button in the group, the button will not be added.
+ ///
+ /// See also <see cref="Efl.Ui.IRadioGroup.Unregister"/>.</summary>
+ /// <param name="radio">The radio button to add to the group.</param>
+ virtual public void Register(Efl.Ui.Radio radio) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_register_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),radio);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Unregister an <see cref="Efl.Ui.Radio"/> button from this group. This will unlink the behavior of this button from the other buttons in the group, but if it still belongs to a layout, it will still be rendered.
+ /// If the button was not registered in the group the call is ignored. If the button was selected, no button will be selected in the group after this call.
+ ///
+ /// See also <see cref="Efl.Ui.IRadioGroup.Register"/>.</summary>
+ /// <param name="radio">The radio button to remove from the group.</param>
+ virtual public void Unregister(Efl.Ui.Radio radio) {
+ Efl.Ui.IRadioGroupConcrete.NativeMethods.efl_ui_radio_group_unregister_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),radio);
+ Eina.Error.RaiseIfUnhandledException();
+ }
+ /// <summary>Currently selected button in a radio button group, or <c>NULL</c> if no button is selected.
+ /// See also <see cref="Efl.Ui.IRadioGroup.SelectedValue"/>.</summary>
+ /// <value>The currently selected radio button in the group, or <c>NULL</c>.</value>
+ public Efl.Ui.Radio SelectedObject {
+ get { return GetSelectedObject(); }
+ set { SetSelectedObject(value); }
+ }
+ /// <summary>The value associated with the currently selected button in the group. Give each radio button in the group a different value using <see cref="Efl.Ui.Radio.StateValue"/>.
+ /// A value of -1 means that no button is selected. Only values associated with the buttons in the group (and -1) can be used.</summary>
+ /// <value>The value of the currently selected radio button, or -1.</value>
+ public int SelectedValue {
+ get { return GetSelectedValue(); }
+ set { SetSelectedValue(value); }
+ }
+ private static IntPtr GetEflClassStatic()
+ {
+ return Efl.Ui.RadioGroupImpl.efl_ui_radio_group_impl_class_get();
+ }
+ /// <summary>Wrapper for native methods and virtual method delegates.
+ /// For internal use by generated code only.</summary>
+ public new class NativeMethods : Efl.Object.NativeMethods
+ {
+ private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Elementary);
+ /// <summary>Gets the list of Eo operations to override.</summary>
+ /// <returns>The list of Eo operations to be overload.</returns>
+ public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
+ {
+ var descs = new System.Collections.Generic.List<Efl_Op_Description>();
+ var methods = Efl.Eo.Globals.GetUserMethods(type);
+
+ if (efl_ui_radio_group_selected_object_get_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_object_get_static_delegate = new efl_ui_radio_group_selected_object_get_delegate(selected_object_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetSelectedObject") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_object_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_object_get_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_object_set_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_object_set_static_delegate = new efl_ui_radio_group_selected_object_set_delegate(selected_object_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetSelectedObject") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_object_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_object_set_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_value_get_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_value_get_static_delegate = new efl_ui_radio_group_selected_value_get_delegate(selected_value_get);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "GetSelectedValue") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_value_get_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_selected_value_set_static_delegate == null)
+ {
+ efl_ui_radio_group_selected_value_set_static_delegate = new efl_ui_radio_group_selected_value_set_delegate(selected_value_set);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "SetSelectedValue") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_selected_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_selected_value_set_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_register_static_delegate == null)
+ {
+ efl_ui_radio_group_register_static_delegate = new efl_ui_radio_group_register_delegate(register);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Register") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_register"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_register_static_delegate) });
+ }
+
+ if (efl_ui_radio_group_unregister_static_delegate == null)
+ {
+ efl_ui_radio_group_unregister_static_delegate = new efl_ui_radio_group_unregister_delegate(unregister);
+ }
+
+ if (methods.FirstOrDefault(m => m.Name == "Unregister") != null)
+ {
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_radio_group_unregister"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_radio_group_unregister_static_delegate) });
+ }
+
+ descs.AddRange(base.GetEoOps(type));
+ return descs;
+ }
+ /// <summary>Returns the Eo class for the native methods of this class.</summary>
+ /// <returns>The native class pointer.</returns>
+ public override IntPtr GetEflClass()
+ {
+ return Efl.Ui.RadioGroupImpl.efl_ui_radio_group_impl_class_get();
+ }
+
+ #pragma warning disable CA1707, CS1591, SA1300, SA1600
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ private delegate Efl.Ui.Radio efl_ui_radio_group_selected_object_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+ [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
+ public delegate Efl.Ui.Radio efl_ui_radio_group_selected_object_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_get_api_delegate> efl_ui_radio_group_selected_object_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_get_api_delegate>(Module, "efl_ui_radio_group_selected_object_get");
+
+ private static Efl.Ui.Radio selected_object_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_object_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ Efl.Ui.Radio _ret_var = default(Efl.Ui.Radio);
+ try
+ {
+ _ret_var = ((RadioGroupImpl)ws.Target).GetSelectedObject();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_radio_group_selected_object_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_radio_group_selected_object_get_delegate efl_ui_radio_group_selected_object_get_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_selected_object_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio selected_object);
+
+
+ public delegate void efl_ui_radio_group_selected_object_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio selected_object);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_set_api_delegate> efl_ui_radio_group_selected_object_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_object_set_api_delegate>(Module, "efl_ui_radio_group_selected_object_set");
+
+ private static void selected_object_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio selected_object)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_object_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioGroupImpl)ws.Target).SetSelectedObject(selected_object);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_selected_object_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_object);
+ }
+ }
+
+ private static efl_ui_radio_group_selected_object_set_delegate efl_ui_radio_group_selected_object_set_static_delegate;
+
+
+ private delegate int efl_ui_radio_group_selected_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
+
+
+ public delegate int efl_ui_radio_group_selected_value_get_api_delegate(System.IntPtr obj);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_get_api_delegate> efl_ui_radio_group_selected_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_get_api_delegate>(Module, "efl_ui_radio_group_selected_value_get");
+
+ private static int selected_value_get(System.IntPtr obj, System.IntPtr pd)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_value_get was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+ int _ret_var = default(int);
+ try
+ {
+ _ret_var = ((RadioGroupImpl)ws.Target).GetSelectedValue();
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+ return _ret_var;
+
+ }
+ else
+ {
+ return efl_ui_radio_group_selected_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
+ }
+ }
+
+ private static efl_ui_radio_group_selected_value_get_delegate efl_ui_radio_group_selected_value_get_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_selected_value_set_delegate(System.IntPtr obj, System.IntPtr pd, int selected_value);
+
+
+ public delegate void efl_ui_radio_group_selected_value_set_api_delegate(System.IntPtr obj, int selected_value);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_set_api_delegate> efl_ui_radio_group_selected_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_selected_value_set_api_delegate>(Module, "efl_ui_radio_group_selected_value_set");
+
+ private static void selected_value_set(System.IntPtr obj, System.IntPtr pd, int selected_value)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_selected_value_set was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioGroupImpl)ws.Target).SetSelectedValue(selected_value);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_selected_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), selected_value);
+ }
+ }
+
+ private static efl_ui_radio_group_selected_value_set_delegate efl_ui_radio_group_selected_value_set_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_register_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+
+ public delegate void efl_ui_radio_group_register_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_register_api_delegate> efl_ui_radio_group_register_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_register_api_delegate>(Module, "efl_ui_radio_group_register");
+
+ private static void register(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio radio)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_register was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioGroupImpl)ws.Target).Register(radio);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_register_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radio);
+ }
+ }
+
+ private static efl_ui_radio_group_register_delegate efl_ui_radio_group_register_static_delegate;
+
+
+ private delegate void efl_ui_radio_group_unregister_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+
+ public delegate void efl_ui_radio_group_unregister_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Radio radio);
+
+ public static Efl.Eo.FunctionWrapper<efl_ui_radio_group_unregister_api_delegate> efl_ui_radio_group_unregister_ptr = new Efl.Eo.FunctionWrapper<efl_ui_radio_group_unregister_api_delegate>(Module, "efl_ui_radio_group_unregister");
+
+ private static void unregister(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Radio radio)
+ {
+ Eina.Log.Debug("function efl_ui_radio_group_unregister was called");
+ var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
+ if (ws != null)
+ {
+
+ try
+ {
+ ((RadioGroupImpl)ws.Target).Unregister(radio);
+ }
+ catch (Exception e)
+ {
+ Eina.Log.Warning($"Callback error: {e.ToString()}");
+ Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
+ }
+
+
+ }
+ else
+ {
+ efl_ui_radio_group_unregister_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radio);
+ }
+ }
+
+ private static efl_ui_radio_group_unregister_delegate efl_ui_radio_group_unregister_static_delegate;
+
+ #pragma warning restore CA1707, CS1591, SA1300, SA1600
+
+}
+}
+}
+
+}
+
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
-void GetRangeMinMax(out double min, out double max);
+void GetRangeLimits(out double min, out double max);
/// <summary>Set the minimum and maximum values for given range widget.
/// Define the allowed range of values to be selected by the user.
///
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
-void SetRangeMinMax(double min, double max);
+void SetRangeLimits(double min, double max);
/// <summary>Control the range value (in percentage) on a given range widget
/// Use this call to set range levels.
///
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_range_display_interface_get();
/// <summary>Initializes a new instance of the <see cref="IRangeDisplay"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- public void GetRangeMinMax(out double min, out double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_get_ptr.Value.Delegate(this.NativeHandle,out min, out max);
+ public void GetRangeLimits(out double min, out double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate(this.NativeHandle,out min, out max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Set the minimum and maximum values for given range widget.
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- public void SetRangeMinMax(double min, double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_set_ptr.Value.Delegate(this.NativeHandle,min, max);
+ public void SetRangeLimits(double min, double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate(this.NativeHandle,min, max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Control the range value (in percentage) on a given range widget
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
}
- if (efl_ui_range_min_max_get_static_delegate == null)
+ if (efl_ui_range_limits_get_static_delegate == null)
{
- efl_ui_range_min_max_get_static_delegate = new efl_ui_range_min_max_get_delegate(range_min_max_get);
+ efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
}
- if (efl_ui_range_min_max_set_static_delegate == null)
+ if (efl_ui_range_limits_set_static_delegate == null)
{
- efl_ui_range_min_max_set_static_delegate = new efl_ui_range_min_max_set_delegate(range_min_max_set);
+ efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
}
return descs;
private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
- private delegate void efl_ui_range_min_max_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
+ private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
- public delegate void efl_ui_range_min_max_get_api_delegate(System.IntPtr obj, out double min, out double max);
+ public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj, out double min, out double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate> efl_ui_range_min_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate>(Module, "efl_ui_range_min_max_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
- private static void range_min_max_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
+ private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_get was called");
+ Eina.Log.Debug("function efl_ui_range_limits_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
min = default(double); max = default(double);
try
{
- ((IRangeDisplay)ws.Target).GetRangeMinMax(out min, out max);
+ ((IRangeDisplay)ws.Target).GetRangeLimits(out min, out max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
+ efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
}
}
- private static efl_ui_range_min_max_get_delegate efl_ui_range_min_max_get_static_delegate;
+ private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
- private delegate void efl_ui_range_min_max_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
+ private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
- public delegate void efl_ui_range_min_max_set_api_delegate(System.IntPtr obj, double min, double max);
+ public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj, double min, double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate> efl_ui_range_min_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate>(Module, "efl_ui_range_min_max_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
- private static void range_min_max_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
+ private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_set was called");
+ Eina.Log.Debug("function efl_ui_range_limits_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((IRangeDisplay)ws.Target).SetRangeMinMax(min, max);
+ ((IRangeDisplay)ws.Target).SetRangeLimits(min, max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
+ efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
}
}
- private static efl_ui_range_min_max_set_delegate efl_ui_range_min_max_set_static_delegate;
+ private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
#pragma warning restore CA1707, CS1591, SA1300, SA1600
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_range_interactive_interface_get();
/// <summary>Initializes a new instance of the <see cref="IRangeInteractive"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- public void GetRangeMinMax(out double min, out double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_get_ptr.Value.Delegate(this.NativeHandle,out min, out max);
+ public void GetRangeLimits(out double min, out double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate(this.NativeHandle,out min, out max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Set the minimum and maximum values for given range widget.
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- public void SetRangeMinMax(double min, double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_set_ptr.Value.Delegate(this.NativeHandle,min, max);
+ public void SetRangeLimits(double min, double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate(this.NativeHandle,min, max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Control the step used to increment or decrement values for given widget.
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
}
- if (efl_ui_range_min_max_get_static_delegate == null)
+ if (efl_ui_range_limits_get_static_delegate == null)
{
- efl_ui_range_min_max_get_static_delegate = new efl_ui_range_min_max_get_delegate(range_min_max_get);
+ efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
}
- if (efl_ui_range_min_max_set_static_delegate == null)
+ if (efl_ui_range_limits_set_static_delegate == null)
{
- efl_ui_range_min_max_set_static_delegate = new efl_ui_range_min_max_set_delegate(range_min_max_set);
+ efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
}
return descs;
private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
- private delegate void efl_ui_range_min_max_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
+ private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
- public delegate void efl_ui_range_min_max_get_api_delegate(System.IntPtr obj, out double min, out double max);
+ public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj, out double min, out double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate> efl_ui_range_min_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate>(Module, "efl_ui_range_min_max_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
- private static void range_min_max_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
+ private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_get was called");
+ Eina.Log.Debug("function efl_ui_range_limits_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
min = default(double); max = default(double);
try
{
- ((IRangeInteractive)ws.Target).GetRangeMinMax(out min, out max);
+ ((IRangeInteractive)ws.Target).GetRangeLimits(out min, out max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
+ efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
}
}
- private static efl_ui_range_min_max_get_delegate efl_ui_range_min_max_get_static_delegate;
+ private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
- private delegate void efl_ui_range_min_max_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
+ private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
- public delegate void efl_ui_range_min_max_set_api_delegate(System.IntPtr obj, double min, double max);
+ public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj, double min, double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate> efl_ui_range_min_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate>(Module, "efl_ui_range_min_max_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
- private static void range_min_max_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
+ private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_set was called");
+ Eina.Log.Debug("function efl_ui_range_limits_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((IRangeInteractive)ws.Target).SetRangeMinMax(min, max);
+ ((IRangeInteractive)ws.Target).SetRangeLimits(min, max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
+ efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
}
}
- private static efl_ui_range_min_max_set_delegate efl_ui_range_min_max_set_static_delegate;
+ private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
#pragma warning restore CA1707, CS1591, SA1300, SA1600
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLayoutUpdatedEvt(EventArgs e)
{
var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarSizeChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPosChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// <summary>This is the internal pan object managed by scroll manager.
/// This property is protected as it is meant for scrollable object implementations only, to set and access the internal pan object. If pan is set to NULL, scrolling does not work.</summary>
/// <param name="pan">Pan object</param>
- virtual public void SetPan(Efl.Ui.Pan pan) {
+ virtual protected void SetPan(Efl.Ui.Pan pan) {
Efl.Ui.Scroll.Manager.NativeMethods.efl_ui_scroll_manager_pan_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),pan);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>This is the internal pan object managed by scroll manager.
/// This property is protected as it is meant for scrollable object implementations only, to set and access the internal pan object. If pan is set to NULL, scrolling does not work.</summary>
/// <value>Pan object</value>
- public Efl.Ui.Pan Pan {
+ protected Efl.Ui.Pan Pan {
set { SetPan(value); }
}
/// <summary>Whether this object should be mirrored.
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_scrollable_interface_get();
/// <summary>Initializes a new instance of the <see cref="IScrollable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_scrollable_interactive_interface_get();
/// <summary>Initializes a new instance of the <see cref="IScrollableInteractive"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_scrollbar_interface_get();
/// <summary>Initializes a new instance of the <see cref="IScrollbar"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarSizeChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarPosChangedEvt(EventArgs e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
{
var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_selectable_interface_get();
/// <summary>Initializes a new instance of the <see cref="ISelectable"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
Eina.Future _ret_var = default( Eina.Future);
try
{
- _ret_var = ((ISelectionConcrete)ws.Target).SetSelection(type, format, data, seat);
+ _ret_var = ((ISelection)ws.Target).SetSelection(type, format, data, seat);
}
catch (Exception e)
{
try
{
- ((ISelectionConcrete)ws.Target).GetSelection(type, format, data_func_wrapper.ManagedCb, seat);
+ ((ISelection)ws.Target).GetSelection(type, format, data_func_wrapper.ManagedCb, seat);
}
catch (Exception e)
{
try
{
- ((ISelectionConcrete)ws.Target).ClearSelection(type, seat);
+ ((ISelection)ws.Target).ClearSelection(type, seat);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((ISelectionConcrete)ws.Target).HasOwner(type, seat);
+ _ret_var = ((ISelection)ws.Target).HasOwner(type, seat);
}
catch (Exception e)
{
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void GetRangeMinMax(out double min, out double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
+ virtual public void GetRangeLimits(out double min, out double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Set the minimum and maximum values for given range widget.
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void SetRangeMinMax(double min, double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
+ virtual public void SetRangeLimits(double min, double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Control the step used to increment or decrement values for given widget.
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
}
- if (efl_ui_range_min_max_get_static_delegate == null)
+ if (efl_ui_range_limits_get_static_delegate == null)
{
- efl_ui_range_min_max_get_static_delegate = new efl_ui_range_min_max_get_delegate(range_min_max_get);
+ efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
}
- if (efl_ui_range_min_max_set_static_delegate == null)
+ if (efl_ui_range_limits_set_static_delegate == null)
{
- efl_ui_range_min_max_set_static_delegate = new efl_ui_range_min_max_set_delegate(range_min_max_set);
+ efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
}
if (efl_ui_range_step_get_static_delegate == null)
private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
- private delegate void efl_ui_range_min_max_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
+ private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
- public delegate void efl_ui_range_min_max_get_api_delegate(System.IntPtr obj, out double min, out double max);
+ public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj, out double min, out double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate> efl_ui_range_min_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate>(Module, "efl_ui_range_min_max_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
- private static void range_min_max_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
+ private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_get was called");
+ Eina.Log.Debug("function efl_ui_range_limits_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
min = default(double); max = default(double);
try
{
- ((Slider)ws.Target).GetRangeMinMax(out min, out max);
+ ((Slider)ws.Target).GetRangeLimits(out min, out max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
+ efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
}
}
- private static efl_ui_range_min_max_get_delegate efl_ui_range_min_max_get_static_delegate;
+ private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
- private delegate void efl_ui_range_min_max_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
+ private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
- public delegate void efl_ui_range_min_max_set_api_delegate(System.IntPtr obj, double min, double max);
+ public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj, double min, double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate> efl_ui_range_min_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate>(Module, "efl_ui_range_min_max_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
- private static void range_min_max_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
+ private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_set was called");
+ Eina.Log.Debug("function efl_ui_range_limits_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((Slider)ws.Target).SetRangeMinMax(min, max);
+ ((Slider)ws.Target).SetRangeLimits(min, max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
+ efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
}
}
- private static efl_ui_range_min_max_set_delegate efl_ui_range_min_max_set_static_delegate;
+ private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
private delegate double efl_ui_range_step_get_delegate(System.IntPtr obj, System.IntPtr pd);
/// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void GetRangeMinMax(out double min, out double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
+ virtual public void GetRangeLimits(out double min, out double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Set the minimum and maximum values for given range widget.
/// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
- virtual public void SetRangeMinMax(double min, double max) {
- Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_min_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
+ virtual public void SetRangeLimits(double min, double max) {
+ Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
Eina.Error.RaiseIfUnhandledException();
}
/// <summary>Control the step used to increment or decrement values for given widget.
descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
}
- if (efl_ui_range_min_max_get_static_delegate == null)
+ if (efl_ui_range_limits_get_static_delegate == null)
{
- efl_ui_range_min_max_get_static_delegate = new efl_ui_range_min_max_get_delegate(range_min_max_get);
+ efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
}
- if (methods.FirstOrDefault(m => m.Name == "GetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_get_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
}
- if (efl_ui_range_min_max_set_static_delegate == null)
+ if (efl_ui_range_limits_set_static_delegate == null)
{
- efl_ui_range_min_max_set_static_delegate = new efl_ui_range_min_max_set_delegate(range_min_max_set);
+ efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
}
- if (methods.FirstOrDefault(m => m.Name == "SetRangeMinMax") != null)
+ if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
{
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_min_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_min_max_set_static_delegate) });
+ descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
}
if (efl_ui_range_step_get_static_delegate == null)
private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
- private delegate void efl_ui_range_min_max_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
+ private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd, out double min, out double max);
- public delegate void efl_ui_range_min_max_get_api_delegate(System.IntPtr obj, out double min, out double max);
+ public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj, out double min, out double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate> efl_ui_range_min_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_get_api_delegate>(Module, "efl_ui_range_min_max_get");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
- private static void range_min_max_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
+ private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_get was called");
+ Eina.Log.Debug("function efl_ui_range_limits_get was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
min = default(double); max = default(double);
try
{
- ((Spin)ws.Target).GetRangeMinMax(out min, out max);
+ ((Spin)ws.Target).GetRangeLimits(out min, out max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
+ efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
}
}
- private static efl_ui_range_min_max_get_delegate efl_ui_range_min_max_get_static_delegate;
+ private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
- private delegate void efl_ui_range_min_max_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
+ private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd, double min, double max);
- public delegate void efl_ui_range_min_max_set_api_delegate(System.IntPtr obj, double min, double max);
+ public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj, double min, double max);
- public static Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate> efl_ui_range_min_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_min_max_set_api_delegate>(Module, "efl_ui_range_min_max_set");
+ public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
- private static void range_min_max_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
+ private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
{
- Eina.Log.Debug("function efl_ui_range_min_max_set was called");
+ Eina.Log.Debug("function efl_ui_range_limits_set was called");
var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
if (ws != null)
{
try
{
- ((Spin)ws.Target).SetRangeMinMax(min, max);
+ ((Spin)ws.Target).SetRangeLimits(min, max);
}
catch (Exception e)
{
}
else
{
- efl_ui_range_min_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
+ efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
}
}
- private static efl_ui_range_min_max_set_delegate efl_ui_range_min_max_set_static_delegate;
+ private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
private delegate double efl_ui_range_step_get_delegate(System.IntPtr obj, System.IntPtr pd);
+++ /dev/null
-#pragma warning disable CS1591
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.ComponentModel;
-namespace Efl {
-
-namespace Ui {
-
-///<summary>Event argument wrapper for event <see cref="Efl.Ui.Stack.LoadedEvt"/>.</summary>
-public class StackLoadedEvt_Args : EventArgs {
- ///<summary>Actual event payload.</summary>
- public Efl.Ui.StackEventLoaded arg { get; set; }
-}
-///<summary>Event argument wrapper for event <see cref="Efl.Ui.Stack.UnloadedEvt"/>.</summary>
-public class StackUnloadedEvt_Args : EventArgs {
- ///<summary>Actual event payload.</summary>
- public Efl.Ui.StackEventUnloaded arg { get; set; }
-}
-///<summary>Event argument wrapper for event <see cref="Efl.Ui.Stack.ActivatedEvt"/>.</summary>
-public class StackActivatedEvt_Args : EventArgs {
- ///<summary>Actual event payload.</summary>
- public Efl.Ui.StackEventActivated arg { get; set; }
-}
-///<summary>Event argument wrapper for event <see cref="Efl.Ui.Stack.DeactivatedEvt"/>.</summary>
-public class StackDeactivatedEvt_Args : EventArgs {
- ///<summary>Actual event payload.</summary>
- public Efl.Ui.StackEventDeactivated arg { get; set; }
-}
-/// <summary>Stack widget.
-/// Stack widget arranges objects in stack structure by pushing and poping them.</summary>
-[Efl.Ui.Stack.NativeMethods]
-public class Stack : Efl.Ui.LayoutBase
-{
- ///<summary>Pointer to the native class description.</summary>
- public override System.IntPtr NativeClass
- {
- get
- {
- if (((object)this).GetType() == typeof(Stack))
- {
- return GetEflClassStatic();
- }
- else
- {
- return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
- }
- }
- }
-
- [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
- efl_ui_stack_class_get();
- /// <summary>Initializes a new instance of the <see cref="Stack"/> class.</summary>
- /// <param name="parent">Parent instance.</param>
- /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
- public Stack(Efl.Object parent
- , System.String style = null) : base(efl_ui_stack_class_get(), typeof(Stack), parent)
- {
- if (Efl.Eo.Globals.ParamHelperCheck(style))
- {
- SetStyle(Efl.Eo.Globals.GetParamHelper(style));
- }
-
- FinishInstantiation();
- }
-
- /// <summary>Initializes a new instance of the <see cref="Stack"/> class.
- /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
- /// <param name="raw">The native pointer to be wrapped.</param>
- protected Stack(System.IntPtr raw) : base(raw)
- {
- }
-
- /// <summary>Initializes a new instance of the <see cref="Stack"/> class.
- /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
- /// <param name="baseKlass">The pointer to the base native Eo class.</param>
- /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
- /// <param name="parent">The Efl.Object parent of this instance.</param>
- protected Stack(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
- {
- }
-
- /// <summary>Called when content is loaded right before transition.</summary>
- public event EventHandler<Efl.Ui.StackLoadedEvt_Args> LoadedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Ui.StackLoadedEvt_Args args = new Efl.Ui.StackLoadedEvt_Args();
- args.arg = evt.Info;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_UI_STACK_EVENT_LOADED";
- AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_UI_STACK_EVENT_LOADED";
- RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
- }
- }
- }
- ///<summary>Method to raise event LoadedEvt.</summary>
- public void OnLoadedEvt(Efl.Ui.StackLoadedEvt_Args e)
- {
- var key = "_EFL_UI_STACK_EVENT_LOADED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
- try
- {
- Marshal.StructureToPtr(e.arg, info, false);
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Called when content is unloaded right after being deactivated.</summary>
- public event EventHandler<Efl.Ui.StackUnloadedEvt_Args> UnloadedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Ui.StackUnloadedEvt_Args args = new Efl.Ui.StackUnloadedEvt_Args();
- args.arg = evt.Info;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_UI_STACK_EVENT_UNLOADED";
- AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_UI_STACK_EVENT_UNLOADED";
- RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
- }
- }
- }
- ///<summary>Method to raise event UnloadedEvt.</summary>
- public void OnUnloadedEvt(Efl.Ui.StackUnloadedEvt_Args e)
- {
- var key = "_EFL_UI_STACK_EVENT_UNLOADED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
- try
- {
- Marshal.StructureToPtr(e.arg, info, false);
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Called when content is activated right after transition.</summary>
- public event EventHandler<Efl.Ui.StackActivatedEvt_Args> ActivatedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Ui.StackActivatedEvt_Args args = new Efl.Ui.StackActivatedEvt_Args();
- args.arg = evt.Info;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_UI_STACK_EVENT_ACTIVATED";
- AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_UI_STACK_EVENT_ACTIVATED";
- RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
- }
- }
- }
- ///<summary>Method to raise event ActivatedEvt.</summary>
- public void OnActivatedEvt(Efl.Ui.StackActivatedEvt_Args e)
- {
- var key = "_EFL_UI_STACK_EVENT_ACTIVATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
- try
- {
- Marshal.StructureToPtr(e.arg, info, false);
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Called when content is deactivated right after transition.</summary>
- public event EventHandler<Efl.Ui.StackDeactivatedEvt_Args> DeactivatedEvt
- {
- add
- {
- lock (eventLock)
- {
- Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
- {
- var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
- if (obj != null)
- {
- Efl.Ui.StackDeactivatedEvt_Args args = new Efl.Ui.StackDeactivatedEvt_Args();
- args.arg = evt.Info;
- try
- {
- value?.Invoke(obj, args);
- }
- catch (Exception e)
- {
- Eina.Log.Error(e.ToString());
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
- }
- };
-
- string key = "_EFL_UI_STACK_EVENT_DEACTIVATED";
- AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
- }
- }
-
- remove
- {
- lock (eventLock)
- {
- string key = "_EFL_UI_STACK_EVENT_DEACTIVATED";
- RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
- }
- }
- }
- ///<summary>Method to raise event DeactivatedEvt.</summary>
- public void OnDeactivatedEvt(Efl.Ui.StackDeactivatedEvt_Args e)
- {
- var key = "_EFL_UI_STACK_EVENT_DEACTIVATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
- if (desc == IntPtr.Zero)
- {
- Eina.Log.Error($"Failed to get native event {key}");
- return;
- }
-
- IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
- try
- {
- Marshal.StructureToPtr(e.arg, info, false);
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
- }
- finally
- {
- Marshal.FreeHGlobal(info);
- }
- }
- /// <summary>Pushes a new object to the top of the stack and shows it.</summary>
- /// <param name="content">The pushed object which becomes the top content of the stack.</param>
- virtual public void Push(Efl.Canvas.Object content) {
- Efl.Ui.Stack.NativeMethods.efl_ui_stack_push_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Pops the top content from the stack and deletes it.</summary>
- /// <returns>The top content which is removed from the stack.</returns>
- virtual public Efl.Canvas.Object Pop() {
- var _ret_var = Efl.Ui.Stack.NativeMethods.efl_ui_stack_pop_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Inserts an object before the given base content in the stack.</summary>
- /// <param name="base_content"><c>content</c> is inserted before this <c>base_content</c>.</param>
- /// <param name="content">The inserted object in the stack.</param>
- virtual public void InsertBefore(Efl.Canvas.Object base_content, Efl.Canvas.Object content) {
- Efl.Ui.Stack.NativeMethods.efl_ui_stack_insert_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),base_content, content);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Inserts an object after the given base content in the stack.</summary>
- /// <param name="base_content"><c>content</c> is inserted after this <c>base_content</c>.</param>
- /// <param name="content">The inserted object in the stack.</param>
- virtual public void InsertAfter(Efl.Canvas.Object base_content, Efl.Canvas.Object content) {
- Efl.Ui.Stack.NativeMethods.efl_ui_stack_insert_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),base_content, content);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Inserts an object at the given place in the stack.</summary>
- /// <param name="index">The index of the inserted object in the stack. <c>index</c> begins from bottom to top of the stack. <c>index</c> of the bottom content is 0.</param>
- /// <param name="content">The inserted object in the stack.</param>
- virtual public void InsertAt(int index, Efl.Canvas.Object content) {
- Efl.Ui.Stack.NativeMethods.efl_ui_stack_insert_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index, content);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Removes the given content in the stack.</summary>
- /// <param name="content">The removed content from the stack.</param>
- virtual public void Remove(Efl.Canvas.Object content) {
- Efl.Ui.Stack.NativeMethods.efl_ui_stack_remove_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Removes a content matched to the given index in the stack.</summary>
- /// <param name="index">The index of the removed object in the stack. <c>index</c> begins from bottom to top of the stack. <c>index</c> of the bottom content is 0.</param>
- virtual public void RemoveAt(int index) {
- Efl.Ui.Stack.NativeMethods.efl_ui_stack_remove_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
- Eina.Error.RaiseIfUnhandledException();
- }
- /// <summary>Gets the index of the given content in the stack. The index begins from bottom to top of the stack. The index of the bottom content is 0.</summary>
- /// <param name="content">The content matched to the index to be returned in the stack.</param>
- /// <returns>The index of <c>content</c> in the stack.</returns>
- virtual public int GetIndex(Efl.Canvas.Object content) {
- var _ret_var = Efl.Ui.Stack.NativeMethods.efl_ui_stack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Gets the content matched to the given index in the stack.</summary>
- /// <param name="index">The index of the content to be returned in the stack.</param>
- /// <returns>The content matched to <c>index</c> in the stack.</returns>
- virtual public Efl.Canvas.Object GetContent(int index) {
- var _ret_var = Efl.Ui.Stack.NativeMethods.efl_ui_stack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- /// <summary>Gets the top content in the stack.</summary>
- /// <returns>The top content in the stack.</returns>
- virtual public Efl.Canvas.Object Top() {
- var _ret_var = Efl.Ui.Stack.NativeMethods.efl_ui_stack_top_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
- Eina.Error.RaiseIfUnhandledException();
- return _ret_var;
- }
- private static IntPtr GetEflClassStatic()
- {
- return Efl.Ui.Stack.efl_ui_stack_class_get();
- }
- /// <summary>Wrapper for native methods and virtual method delegates.
- /// For internal use by generated code only.</summary>
- public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
- {
- private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Elementary);
- /// <summary>Gets the list of Eo operations to override.</summary>
- /// <returns>The list of Eo operations to be overload.</returns>
- public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
- {
- var descs = new System.Collections.Generic.List<Efl_Op_Description>();
- var methods = Efl.Eo.Globals.GetUserMethods(type);
-
- if (efl_ui_stack_push_static_delegate == null)
- {
- efl_ui_stack_push_static_delegate = new efl_ui_stack_push_delegate(push);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Push") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_push"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_push_static_delegate) });
- }
-
- if (efl_ui_stack_pop_static_delegate == null)
- {
- efl_ui_stack_pop_static_delegate = new efl_ui_stack_pop_delegate(pop);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Pop") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_pop"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_pop_static_delegate) });
- }
-
- if (efl_ui_stack_insert_before_static_delegate == null)
- {
- efl_ui_stack_insert_before_static_delegate = new efl_ui_stack_insert_before_delegate(insert_before);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "InsertBefore") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_insert_before"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_insert_before_static_delegate) });
- }
-
- if (efl_ui_stack_insert_after_static_delegate == null)
- {
- efl_ui_stack_insert_after_static_delegate = new efl_ui_stack_insert_after_delegate(insert_after);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "InsertAfter") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_insert_after"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_insert_after_static_delegate) });
- }
-
- if (efl_ui_stack_insert_at_static_delegate == null)
- {
- efl_ui_stack_insert_at_static_delegate = new efl_ui_stack_insert_at_delegate(insert_at);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "InsertAt") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_insert_at"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_insert_at_static_delegate) });
- }
-
- if (efl_ui_stack_remove_static_delegate == null)
- {
- efl_ui_stack_remove_static_delegate = new efl_ui_stack_remove_delegate(remove);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Remove") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_remove"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_remove_static_delegate) });
- }
-
- if (efl_ui_stack_remove_at_static_delegate == null)
- {
- efl_ui_stack_remove_at_static_delegate = new efl_ui_stack_remove_at_delegate(remove_at);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "RemoveAt") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_remove_at"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_remove_at_static_delegate) });
- }
-
- if (efl_ui_stack_index_get_static_delegate == null)
- {
- efl_ui_stack_index_get_static_delegate = new efl_ui_stack_index_get_delegate(index_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetIndex") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_index_get_static_delegate) });
- }
-
- if (efl_ui_stack_content_get_static_delegate == null)
- {
- efl_ui_stack_content_get_static_delegate = new efl_ui_stack_content_get_delegate(content_get);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_content_get_static_delegate) });
- }
-
- if (efl_ui_stack_top_static_delegate == null)
- {
- efl_ui_stack_top_static_delegate = new efl_ui_stack_top_delegate(top);
- }
-
- if (methods.FirstOrDefault(m => m.Name == "Top") != null)
- {
- descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_stack_top"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_stack_top_static_delegate) });
- }
-
- descs.AddRange(base.GetEoOps(type));
- return descs;
- }
- /// <summary>Returns the Eo class for the native methods of this class.</summary>
- /// <returns>The native class pointer.</returns>
- public override IntPtr GetEflClass()
- {
- return Efl.Ui.Stack.efl_ui_stack_class_get();
- }
-
- #pragma warning disable CA1707, CS1591, SA1300, SA1600
-
-
- private delegate void efl_ui_stack_push_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
-
- public delegate void efl_ui_stack_push_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_push_api_delegate> efl_ui_stack_push_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_push_api_delegate>(Module, "efl_ui_stack_push");
-
- private static void push(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object content)
- {
- Eina.Log.Debug("function efl_ui_stack_push was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Stack)ws.Target).Push(content);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_stack_push_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
- }
- }
-
- private static efl_ui_stack_push_delegate efl_ui_stack_push_static_delegate;
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- private delegate Efl.Canvas.Object efl_ui_stack_pop_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- public delegate Efl.Canvas.Object efl_ui_stack_pop_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_pop_api_delegate> efl_ui_stack_pop_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_pop_api_delegate>(Module, "efl_ui_stack_pop");
-
- private static Efl.Canvas.Object pop(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_ui_stack_pop was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
- try
- {
- _ret_var = ((Stack)ws.Target).Pop();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_ui_stack_pop_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_ui_stack_pop_delegate efl_ui_stack_pop_static_delegate;
-
-
- private delegate void efl_ui_stack_insert_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object base_content, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
-
- public delegate void efl_ui_stack_insert_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object base_content, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_insert_before_api_delegate> efl_ui_stack_insert_before_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_insert_before_api_delegate>(Module, "efl_ui_stack_insert_before");
-
- private static void insert_before(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object base_content, Efl.Canvas.Object content)
- {
- Eina.Log.Debug("function efl_ui_stack_insert_before was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Stack)ws.Target).InsertBefore(base_content, content);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_stack_insert_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), base_content, content);
- }
- }
-
- private static efl_ui_stack_insert_before_delegate efl_ui_stack_insert_before_static_delegate;
-
-
- private delegate void efl_ui_stack_insert_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object base_content, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
-
- public delegate void efl_ui_stack_insert_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object base_content, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_insert_after_api_delegate> efl_ui_stack_insert_after_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_insert_after_api_delegate>(Module, "efl_ui_stack_insert_after");
-
- private static void insert_after(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object base_content, Efl.Canvas.Object content)
- {
- Eina.Log.Debug("function efl_ui_stack_insert_after was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Stack)ws.Target).InsertAfter(base_content, content);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_stack_insert_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), base_content, content);
- }
- }
-
- private static efl_ui_stack_insert_after_delegate efl_ui_stack_insert_after_static_delegate;
-
-
- private delegate void efl_ui_stack_insert_at_delegate(System.IntPtr obj, System.IntPtr pd, int index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
-
- public delegate void efl_ui_stack_insert_at_api_delegate(System.IntPtr obj, int index, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_insert_at_api_delegate> efl_ui_stack_insert_at_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_insert_at_api_delegate>(Module, "efl_ui_stack_insert_at");
-
- private static void insert_at(System.IntPtr obj, System.IntPtr pd, int index, Efl.Canvas.Object content)
- {
- Eina.Log.Debug("function efl_ui_stack_insert_at was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Stack)ws.Target).InsertAt(index, content);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_stack_insert_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index, content);
- }
- }
-
- private static efl_ui_stack_insert_at_delegate efl_ui_stack_insert_at_static_delegate;
-
-
- private delegate void efl_ui_stack_remove_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
-
- public delegate void efl_ui_stack_remove_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_remove_api_delegate> efl_ui_stack_remove_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_remove_api_delegate>(Module, "efl_ui_stack_remove");
-
- private static void remove(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object content)
- {
- Eina.Log.Debug("function efl_ui_stack_remove was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Stack)ws.Target).Remove(content);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_stack_remove_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
- }
- }
-
- private static efl_ui_stack_remove_delegate efl_ui_stack_remove_static_delegate;
-
-
- private delegate void efl_ui_stack_remove_at_delegate(System.IntPtr obj, System.IntPtr pd, int index);
-
-
- public delegate void efl_ui_stack_remove_at_api_delegate(System.IntPtr obj, int index);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_remove_at_api_delegate> efl_ui_stack_remove_at_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_remove_at_api_delegate>(Module, "efl_ui_stack_remove_at");
-
- private static void remove_at(System.IntPtr obj, System.IntPtr pd, int index)
- {
- Eina.Log.Debug("function efl_ui_stack_remove_at was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
-
- try
- {
- ((Stack)ws.Target).RemoveAt(index);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
-
- }
- else
- {
- efl_ui_stack_remove_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
- }
- }
-
- private static efl_ui_stack_remove_at_delegate efl_ui_stack_remove_at_static_delegate;
-
-
- private delegate int efl_ui_stack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
-
- public delegate int efl_ui_stack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Object content);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_index_get_api_delegate> efl_ui_stack_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_index_get_api_delegate>(Module, "efl_ui_stack_index_get");
-
- private static int index_get(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Object content)
- {
- Eina.Log.Debug("function efl_ui_stack_index_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- int _ret_var = default(int);
- try
- {
- _ret_var = ((Stack)ws.Target).GetIndex(content);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_ui_stack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
- }
- }
-
- private static efl_ui_stack_index_get_delegate efl_ui_stack_index_get_static_delegate;
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- private delegate Efl.Canvas.Object efl_ui_stack_content_get_delegate(System.IntPtr obj, System.IntPtr pd, int index);
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- public delegate Efl.Canvas.Object efl_ui_stack_content_get_api_delegate(System.IntPtr obj, int index);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_content_get_api_delegate> efl_ui_stack_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_content_get_api_delegate>(Module, "efl_ui_stack_content_get");
-
- private static Efl.Canvas.Object content_get(System.IntPtr obj, System.IntPtr pd, int index)
- {
- Eina.Log.Debug("function efl_ui_stack_content_get was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
- try
- {
- _ret_var = ((Stack)ws.Target).GetContent(index);
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_ui_stack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
- }
- }
-
- private static efl_ui_stack_content_get_delegate efl_ui_stack_content_get_static_delegate;
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- private delegate Efl.Canvas.Object efl_ui_stack_top_delegate(System.IntPtr obj, System.IntPtr pd);
-
- [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
- public delegate Efl.Canvas.Object efl_ui_stack_top_api_delegate(System.IntPtr obj);
-
- public static Efl.Eo.FunctionWrapper<efl_ui_stack_top_api_delegate> efl_ui_stack_top_ptr = new Efl.Eo.FunctionWrapper<efl_ui_stack_top_api_delegate>(Module, "efl_ui_stack_top");
-
- private static Efl.Canvas.Object top(System.IntPtr obj, System.IntPtr pd)
- {
- Eina.Log.Debug("function efl_ui_stack_top was called");
- var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
- if (ws != null)
- {
- Efl.Canvas.Object _ret_var = default(Efl.Canvas.Object);
- try
- {
- _ret_var = ((Stack)ws.Target).Top();
- }
- catch (Exception e)
- {
- Eina.Log.Warning($"Callback error: {e.ToString()}");
- Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
- }
-
- return _ret_var;
-
- }
- else
- {
- return efl_ui_stack_top_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
- }
- }
-
- private static efl_ui_stack_top_delegate efl_ui_stack_top_static_delegate;
-
- #pragma warning restore CA1707, CS1591, SA1300, SA1600
-
-}
-}
-}
-
-}
-
-namespace Efl {
-
-namespace Ui {
-
-/// <summary>Information of loaded event.</summary>
-[StructLayout(LayoutKind.Sequential)]
-public struct StackEventLoaded
-{
- /// <summary>Loaded content.</summary>
- public Efl.Canvas.Object Content;
- ///<summary>Constructor for StackEventLoaded.</summary>
- public StackEventLoaded(
- Efl.Canvas.Object Content = default(Efl.Canvas.Object) )
- {
- this.Content = Content;
- }
-
- ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
- ///<param name="ptr">Native pointer to be converted.</param>
- public static implicit operator StackEventLoaded(IntPtr ptr)
- {
- var tmp = (StackEventLoaded.NativeStruct)Marshal.PtrToStructure(ptr, typeof(StackEventLoaded.NativeStruct));
- return tmp;
- }
-
- #pragma warning disable CS1591
-
- ///<summary>Internal wrapper for struct StackEventLoaded.</summary>
- [StructLayout(LayoutKind.Sequential)]
- public struct NativeStruct
- {
- ///<summary>Internal wrapper for field Content</summary>
- public System.IntPtr Content;
- ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
- public static implicit operator StackEventLoaded.NativeStruct(StackEventLoaded _external_struct)
- {
- var _internal_struct = new StackEventLoaded.NativeStruct();
- _internal_struct.Content = _external_struct.Content?.NativeHandle ?? System.IntPtr.Zero;
- return _internal_struct;
- }
-
- ///<summary>Implicit conversion to the managed representation.</summary>
- public static implicit operator StackEventLoaded(StackEventLoaded.NativeStruct _internal_struct)
- {
- var _external_struct = new StackEventLoaded();
-
- _external_struct.Content = (Efl.Canvas.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Content);
- return _external_struct;
- }
-
- }
-
- #pragma warning restore CS1591
-
-}
-
-}
-
-}
-
-namespace Efl {
-
-namespace Ui {
-
-/// <summary>Information of unloaded event.</summary>
-[StructLayout(LayoutKind.Sequential)]
-public struct StackEventUnloaded
-{
- /// <summary>Unloaded content.</summary>
- public Efl.Canvas.Object Content;
- ///<summary>Constructor for StackEventUnloaded.</summary>
- public StackEventUnloaded(
- Efl.Canvas.Object Content = default(Efl.Canvas.Object) )
- {
- this.Content = Content;
- }
-
- ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
- ///<param name="ptr">Native pointer to be converted.</param>
- public static implicit operator StackEventUnloaded(IntPtr ptr)
- {
- var tmp = (StackEventUnloaded.NativeStruct)Marshal.PtrToStructure(ptr, typeof(StackEventUnloaded.NativeStruct));
- return tmp;
- }
-
- #pragma warning disable CS1591
-
- ///<summary>Internal wrapper for struct StackEventUnloaded.</summary>
- [StructLayout(LayoutKind.Sequential)]
- public struct NativeStruct
- {
- ///<summary>Internal wrapper for field Content</summary>
- public System.IntPtr Content;
- ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
- public static implicit operator StackEventUnloaded.NativeStruct(StackEventUnloaded _external_struct)
- {
- var _internal_struct = new StackEventUnloaded.NativeStruct();
- _internal_struct.Content = _external_struct.Content?.NativeHandle ?? System.IntPtr.Zero;
- return _internal_struct;
- }
-
- ///<summary>Implicit conversion to the managed representation.</summary>
- public static implicit operator StackEventUnloaded(StackEventUnloaded.NativeStruct _internal_struct)
- {
- var _external_struct = new StackEventUnloaded();
-
- _external_struct.Content = (Efl.Canvas.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Content);
- return _external_struct;
- }
-
- }
-
- #pragma warning restore CS1591
-
-}
-
-}
-
-}
-
-namespace Efl {
-
-namespace Ui {
-
-/// <summary>Information of activated event.</summary>
-[StructLayout(LayoutKind.Sequential)]
-public struct StackEventActivated
-{
- /// <summary>Activated content.</summary>
- public Efl.Canvas.Object Content;
- ///<summary>Constructor for StackEventActivated.</summary>
- public StackEventActivated(
- Efl.Canvas.Object Content = default(Efl.Canvas.Object) )
- {
- this.Content = Content;
- }
-
- ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
- ///<param name="ptr">Native pointer to be converted.</param>
- public static implicit operator StackEventActivated(IntPtr ptr)
- {
- var tmp = (StackEventActivated.NativeStruct)Marshal.PtrToStructure(ptr, typeof(StackEventActivated.NativeStruct));
- return tmp;
- }
-
- #pragma warning disable CS1591
-
- ///<summary>Internal wrapper for struct StackEventActivated.</summary>
- [StructLayout(LayoutKind.Sequential)]
- public struct NativeStruct
- {
- ///<summary>Internal wrapper for field Content</summary>
- public System.IntPtr Content;
- ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
- public static implicit operator StackEventActivated.NativeStruct(StackEventActivated _external_struct)
- {
- var _internal_struct = new StackEventActivated.NativeStruct();
- _internal_struct.Content = _external_struct.Content?.NativeHandle ?? System.IntPtr.Zero;
- return _internal_struct;
- }
-
- ///<summary>Implicit conversion to the managed representation.</summary>
- public static implicit operator StackEventActivated(StackEventActivated.NativeStruct _internal_struct)
- {
- var _external_struct = new StackEventActivated();
-
- _external_struct.Content = (Efl.Canvas.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Content);
- return _external_struct;
- }
-
- }
-
- #pragma warning restore CS1591
-
-}
-
-}
-
-}
-
-namespace Efl {
-
-namespace Ui {
-
-/// <summary>Information of deactivated event.</summary>
-[StructLayout(LayoutKind.Sequential)]
-public struct StackEventDeactivated
-{
- /// <summary>Deactivated content.</summary>
- public Efl.Canvas.Object Content;
- ///<summary>Constructor for StackEventDeactivated.</summary>
- public StackEventDeactivated(
- Efl.Canvas.Object Content = default(Efl.Canvas.Object) )
- {
- this.Content = Content;
- }
-
- ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
- ///<param name="ptr">Native pointer to be converted.</param>
- public static implicit operator StackEventDeactivated(IntPtr ptr)
- {
- var tmp = (StackEventDeactivated.NativeStruct)Marshal.PtrToStructure(ptr, typeof(StackEventDeactivated.NativeStruct));
- return tmp;
- }
-
- #pragma warning disable CS1591
-
- ///<summary>Internal wrapper for struct StackEventDeactivated.</summary>
- [StructLayout(LayoutKind.Sequential)]
- public struct NativeStruct
- {
- ///<summary>Internal wrapper for field Content</summary>
- public System.IntPtr Content;
- ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
- public static implicit operator StackEventDeactivated.NativeStruct(StackEventDeactivated _external_struct)
- {
- var _internal_struct = new StackEventDeactivated.NativeStruct();
- _internal_struct.Content = _external_struct.Content?.NativeHandle ?? System.IntPtr.Zero;
- return _internal_struct;
- }
-
- ///<summary>Implicit conversion to the managed representation.</summary>
- public static implicit operator StackEventDeactivated(StackEventDeactivated.NativeStruct _internal_struct)
- {
- var _external_struct = new StackEventDeactivated();
-
- _external_struct.Content = (Efl.Canvas.Object) Efl.Eo.Globals.CreateWrapperFor(_internal_struct.Content);
- return _external_struct;
- }
-
- }
-
- #pragma warning restore CS1591
-
-}
-
-}
-
-}
-
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
{
var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnLayoutUpdatedEvt(EventArgs e)
{
var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_SELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemSelectedEvt(Efl.Ui.ISelectableItemSelectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_SELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnItemUnselectedEvt(Efl.Ui.ISelectableItemUnselectedEvt_Args e)
{
var key = "_EFL_UI_EVENT_ITEM_UNSELECTED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_PASTE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionPasteEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_PASTE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_COPY";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCopyEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_COPY";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionCutEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionChangedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnSelectionClearedEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SELECTION_CLEARED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_view_interface_get();
/// <summary>Initializes a new instance of the <see cref="IView"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
};
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnPropertiesChangedEvt(Efl.Ui.IPropertyBindPropertiesChangedEvt_Args e)
{
var key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnPropertyBoundEvt(Efl.Ui.IPropertyBindPropertyBoundEvt_Args e)
{
var key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// <summary>Sets the new resize object for this widget.
/// (Since EFL 1.22)</summary>
/// <param name="sobj">A canvas object (often a <see cref="Efl.Canvas.Layout"/> object).</param>
- virtual public void SetResizeObject(Efl.Canvas.Object sobj) {
+ virtual protected void SetResizeObject(Efl.Canvas.Object sobj) {
Efl.Ui.Widget.NativeMethods.efl_ui_widget_resize_object_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sobj);
Eina.Error.RaiseIfUnhandledException();
}
/// (Since EFL 1.22)</summary>
/// <param name="style">Name of the style to use. Refer to each widget's documentation for the available style names, or to the themes in use.</param>
/// <returns>Whether the style was successfully applied or not, see the Efl.Ui.Theme.Apply_Error subset of <see cref="Eina.Error"/> for more information.</returns>
- virtual public Eina.Error SetStyle(System.String style) {
+ virtual protected Eina.Error SetStyle(System.String style) {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_style_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),style);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// <see cref="Efl.Ui.Widget"/> objects have a parent hierarchy that may differ slightly from their <see cref="Efl.Object"/> or <see cref="Efl.Canvas.Object"/> hierarchy. This is meant for internal handling.
/// (Since EFL 1.22)</summary>
/// <returns>Widget parent object</returns>
- virtual public Efl.Ui.Widget GetWidgetParent() {
+ virtual protected Efl.Ui.Widget GetWidgetParent() {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_parent_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// <see cref="Efl.Ui.Widget"/> objects have a parent hierarchy that may differ slightly from their <see cref="Efl.Object"/> or <see cref="Efl.Canvas.Object"/> hierarchy. This is meant for internal handling.
/// (Since EFL 1.22)</summary>
/// <param name="parent">Widget parent object</param>
- virtual public void SetWidgetParent(Efl.Ui.Widget parent) {
+ virtual protected void SetWidgetParent(Efl.Ui.Widget parent) {
Efl.Ui.Widget.NativeMethods.efl_ui_widget_parent_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),parent);
Eina.Error.RaiseIfUnhandledException();
}
/// Note: The region is relative to the top-left corner of the widget, i.e. X,Y start from 0,0 to indicate the top-left corner of the widget. W,H must be greater or equal to 1 for this region to be taken into account, otherwise it is ignored.
/// (Since EFL 1.22)</summary>
/// <returns>The relative region to show. If width or height is <= 0 it will be ignored, and no action will be taken.</returns>
- virtual public Eina.Rect GetInterestRegion() {
+ virtual protected Eina.Rect GetInterestRegion() {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_interest_region_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// <summary>This is a read-only property.
/// (Since EFL 1.22)</summary>
/// <returns>The rectangle area.</returns>
- virtual public Eina.Rect GetFocusHighlightGeometry() {
+ virtual protected Eina.Rect GetFocusHighlightGeometry() {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_focus_highlight_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// <param name="eo_event">EO event struct with an Efl.Input.Event as info.</param>
/// <param name="source">Source object where the event originated. Often same as this.</param>
/// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
- virtual public bool WidgetInputEventHandler(ref Efl.Event eo_event, Efl.Canvas.Object source) {
+ virtual protected bool WidgetInputEventHandler(ref Efl.Event eo_event, Efl.Canvas.Object source) {
Efl.Event.NativeStruct _in_eo_event = eo_event;
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_input_event_handler_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ref _in_eo_event, source);
Eina.Error.RaiseIfUnhandledException();
/// (Since EFL 1.22)</summary>
/// <param name="act">Type of activation.</param>
/// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
- virtual public bool OnAccessActivate(Efl.Ui.Activate act) {
+ virtual protected bool OnAccessActivate(Efl.Ui.Activate act) {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_on_access_activate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),act);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// This meant to be overridden by subclasses to support accessibility. This is an unstable API.
/// (Since EFL 1.22)</summary>
/// <param name="enable"><c>true</c> if accessibility is enabled.</param>
- virtual public void UpdateOnAccess(bool enable) {
+ virtual protected void UpdateOnAccess(bool enable) {
Efl.Ui.Widget.NativeMethods.efl_ui_widget_on_access_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),enable);
Eina.Error.RaiseIfUnhandledException();
}
/// (Since EFL 1.22)</summary>
/// <param name="sub_obj">Sub object to be added. Not necessarily a widget itself.</param>
/// <returns>Indicates if the operation succeeded.</returns>
- virtual public bool AddWidgetSubObject(Efl.Canvas.Object sub_obj) {
+ virtual protected bool AddWidgetSubObject(Efl.Canvas.Object sub_obj) {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_sub_object_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sub_obj);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// (Since EFL 1.22)</summary>
/// <param name="sub_obj">Sub object to be removed. Should be a child of this widget.</param>
/// <returns>Indicates if the operation succeeded.</returns>
- virtual public bool DelWidgetSubObject(Efl.Canvas.Object sub_obj) {
+ virtual protected bool DelWidgetSubObject(Efl.Canvas.Object sub_obj) {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_sub_object_del_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),sub_obj);
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// Note: even widgets not based on layouts may override this method to handle widget updates (scale, mirrored mode, etc...).
/// (Since EFL 1.22)</summary>
/// <returns>Indicates success, and if the current theme or default theme was used.</returns>
- virtual public Eina.Error ThemeApply() {
+ virtual protected Eina.Error ThemeApply() {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_theme_apply_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// <summary>Virtual function which checks if this widget can handle passing focus to sub-object, in a given direction.
/// (Since EFL 1.22)</summary>
/// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
- virtual public bool IsFocusDirectionManager() {
+ virtual protected bool IsFocusDirectionManager() {
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_focus_direction_manager_is_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
Eina.Error.RaiseIfUnhandledException();
return _ret_var;
/// <param name="configured_state">The new configuration being set on the widget.</param>
/// <param name="redirect">A redirect object if there is any</param>
/// <returns>Returns <c>true</c> if the widget is registered in the focus manager, <c>false</c> if not.</returns>
- virtual public bool FocusStateApply(Efl.Ui.WidgetFocusState current_state, ref Efl.Ui.WidgetFocusState configured_state, Efl.Ui.Widget redirect) {
+ virtual protected bool FocusStateApply(Efl.Ui.WidgetFocusState current_state, ref Efl.Ui.WidgetFocusState configured_state, Efl.Ui.Widget redirect) {
Efl.Ui.WidgetFocusState.NativeStruct _in_current_state = current_state;
var _out_configured_state = new Efl.Ui.WidgetFocusState.NativeStruct();
var _ret_var = Efl.Ui.Widget.NativeMethods.efl_ui_widget_focus_state_apply_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_current_state, ref _out_configured_state, redirect);
/// This property is protected as it is meant for widget implementations only, to set and access the internal canvas object. Do use this function unless you're implementing a widget.
/// (Since EFL 1.22)</summary>
/// <value>A canvas object (often a <see cref="Efl.Canvas.Layout"/> object).</value>
- public Efl.Canvas.Object ResizeObject {
+ protected Efl.Canvas.Object ResizeObject {
set { SetResizeObject(value); }
}
/// <summary>Whether the widget is enabled (accepts and reacts to user inputs).
/// <value>Name of the style to use. Refer to each widget's documentation for the available style names, or to the themes in use.</value>
public System.String Style {
get { return GetStyle(); }
- set { SetStyle(value); }
+ protected set { SetStyle(value); }
}
/// <summary>The ability for a widget to be focused.
/// Unfocusable objects do nothing when programmatically focused. The nearest focusable parent object the one really getting focus. Also, when they receive mouse input, they will get the event, but not take away the focus from where it was previously.
/// <see cref="Efl.Ui.Widget"/> objects have a parent hierarchy that may differ slightly from their <see cref="Efl.Object"/> or <see cref="Efl.Canvas.Object"/> hierarchy. This is meant for internal handling.
/// (Since EFL 1.22)</summary>
/// <value>Widget parent object</value>
- public Efl.Ui.Widget WidgetParent {
+ protected Efl.Ui.Widget WidgetParent {
get { return GetWidgetParent(); }
set { SetWidgetParent(value); }
}
/// Note: The region is relative to the top-left corner of the widget, i.e. X,Y start from 0,0 to indicate the top-left corner of the widget. W,H must be greater or equal to 1 for this region to be taken into account, otherwise it is ignored.
/// (Since EFL 1.22)</summary>
/// <value>The relative region to show. If width or height is <= 0 it will be ignored, and no action will be taken.</value>
- public Eina.Rect InterestRegion {
+ protected Eina.Rect InterestRegion {
get { return GetInterestRegion(); }
}
/// <summary>The rectangle region to be highlighted on focus.
/// This is a rectangle region where the focus highlight should be displayed.
/// (Since EFL 1.22)</summary>
/// <value>The rectangle area.</value>
- public Eina.Rect FocusHighlightGeometry {
+ protected Eina.Rect FocusHighlightGeometry {
get { return GetFocusHighlightGeometry(); }
}
/// <summary>Focus order property
};
string key = "_EFL_UI_FACTORY_EVENT_CREATED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_FACTORY_EVENT_CREATED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnCreatedEvt(Efl.Ui.IFactoryCreatedEvt_Args e)
{
var key = "_EFL_UI_FACTORY_EVENT_CREATED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnPropertiesChangedEvt(Efl.Ui.IPropertyBindPropertiesChangedEvt_Args e)
{
var key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTIES_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnPropertyBoundEvt(Efl.Ui.IPropertyBindPropertyBoundEvt_Args e)
{
var key = "_EFL_UI_PROPERTY_BIND_EVENT_PROPERTY_BOUND";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).FocusManagerCreate(root);
+ _ret_var = ((IWidgetFocusManager)ws.Target).FocusManagerCreate(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).GetManagerFocus();
+ _ret_var = ((IWidgetFocusManager)ws.Target).GetManagerFocus();
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).SetManagerFocus(focus);
+ ((IWidgetFocusManager)ws.Target).SetManagerFocus(focus);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).GetRedirect();
+ _ret_var = ((IWidgetFocusManager)ws.Target).GetRedirect();
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).SetRedirect(redirect);
+ ((IWidgetFocusManager)ws.Target).SetRedirect(redirect);
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).GetBorderElements();
+ _ret_var = ((IWidgetFocusManager)ws.Target).GetBorderElements();
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).GetViewportElements(_in_viewport);
+ _ret_var = ((IWidgetFocusManager)ws.Target).GetViewportElements(_in_viewport);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).GetRoot();
+ _ret_var = ((IWidgetFocusManager)ws.Target).GetRoot();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).SetRoot(root);
+ _ret_var = ((IWidgetFocusManager)ws.Target).SetRoot(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).Move(direction);
+ _ret_var = ((IWidgetFocusManager)ws.Target).Move(direction);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).MoveRequest(direction, child, logical);
+ _ret_var = ((IWidgetFocusManager)ws.Target).MoveRequest(direction, child, logical);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).RequestSubchild(root);
+ _ret_var = ((IWidgetFocusManager)ws.Target).RequestSubchild(root);
}
catch (Exception e)
{
Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).Fetch(child);
+ _ret_var = ((IWidgetFocusManager)ws.Target).Fetch(child);
}
catch (Exception e)
{
Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
try
{
- _ret_var = ((IWidgetFocusManagerConcrete)ws.Target).LogicalEnd();
+ _ret_var = ((IWidgetFocusManager)ws.Target).LogicalEnd();
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).ResetHistory();
+ ((IWidgetFocusManager)ws.Target).ResetHistory();
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).PopHistoryStack();
+ ((IWidgetFocusManager)ws.Target).PopHistoryStack();
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).SetupOnFirstTouch(direction, entry);
+ ((IWidgetFocusManager)ws.Target).SetupOnFirstTouch(direction, entry);
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).FreezeDirtyLogic();
+ ((IWidgetFocusManager)ws.Target).FreezeDirtyLogic();
}
catch (Exception e)
{
try
{
- ((IWidgetFocusManagerConcrete)ws.Target).DirtyLogicUnfreeze();
+ ((IWidgetFocusManager)ws.Target).DirtyLogicUnfreeze();
}
catch (Exception e)
{
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImagePreloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImageResizeEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnImageUnloadEvt(EventArgs e)
{
var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
/// <summary>Called when scene got focus
/// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Canvas.ISceneSceneFocusInEvt_Args> SceneFocusInEvt
+ public event EventHandler SceneFocusInEvt
{
add
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
- Efl.Canvas.ISceneSceneFocusInEvt_Args args = new Efl.Canvas.ISceneSceneFocusInEvt_Args();
- args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Focus);
+ EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
};
string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
///<summary>Method to raise event SceneFocusInEvt.</summary>
- public void OnSceneFocusInEvt(Efl.Canvas.ISceneSceneFocusInEvt_Args e)
+ public void OnSceneFocusInEvt(EventArgs e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
return;
}
- IntPtr info = e.arg.NativeHandle;
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// <summary>Called when scene lost focus
/// (Since EFL 1.22)</summary>
- public event EventHandler<Efl.Canvas.ISceneSceneFocusOutEvt_Args> SceneFocusOutEvt
+ public event EventHandler SceneFocusOutEvt
{
add
{
var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
if (obj != null)
{
- Efl.Canvas.ISceneSceneFocusOutEvt_Args args = new Efl.Canvas.ISceneSceneFocusOutEvt_Args();
- args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Input.Focus);
+ EventArgs args = EventArgs.Empty;
try
{
value?.Invoke(obj, args);
};
string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
///<summary>Method to raise event SceneFocusOutEvt.</summary>
- public void OnSceneFocusOutEvt(Efl.Canvas.ISceneSceneFocusOutEvt_Args e)
+ public void OnSceneFocusOutEvt(EventArgs e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
return;
}
- IntPtr info = e.arg.NativeHandle;
- Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
+ Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
}
/// <summary>Called when object got focus
/// (Since EFL 1.22)</summary>
};
string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnObjectFocusInEvt(Efl.Canvas.ISceneObjectFocusInEvt_Args e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnObjectFocusOutEvt(Efl.Canvas.ISceneObjectFocusOutEvt_Args e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_PRE";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_PRE";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnRenderPreEvt(EventArgs e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_RENDER_PRE";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_POST";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_RENDER_POST";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnRenderPostEvt(Efl.Canvas.ISceneRenderPostEvt_Args e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_RENDER_POST";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDeviceChangedEvt(Efl.Canvas.ISceneDeviceChangedEvt_Args e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDeviceAddedEvt(Efl.Canvas.ISceneDeviceAddedEvt_Args e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_ADDED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnDeviceRemovedEvt(Efl.Canvas.ISceneDeviceRemovedEvt_Args e)
{
var key = "_EFL_CANVAS_SCENE_EVENT_DEVICE_REMOVED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
/// <summary>Returns an iterator over the current known pointer positions.
/// This is used to iterate over the current known multi-touch positions, including the first finger. Each pointer position is represented by an object of type <see cref="Efl.Input.Pointer"/>.
///
- /// Each finger in a multi touch environment can then be identified by the <see cref="Efl.Input.Pointer.Tool"/> property. The order of the pointers in this iterator is not defined.
+ /// Each finger in a multi touch environment can then be identified by the <see cref="Efl.Input.Pointer.TouchId"/> property. The order of the pointers in this iterator is not defined.
///
/// Note: If the input surface supports hovering input, some pointers may not be in a "down" state. To retrieve the list of such pointers, set the <c>hover</c> value to <c>true</c>. Remember though that most devices currently don't support this.
/// (Since EFL 1.22)</summary>
};
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
{
var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
}
}
- [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
+ [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
efl_ui_zoom_interface_get();
/// <summary>Initializes a new instance of the <see cref="IZoom"/> class.
/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
[DllImport(efl.Libs.CustomExports)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
+ internal static extern bool eina_value_container_append_wrapper_ptr(IntPtr handle, IntPtr data);
+
+ [DllImport(efl.Libs.CustomExports)]
+ [return: MarshalAsAttribute(UnmanagedType.U1)]
internal static extern bool eina_value_container_append_wrapper_char(IntPtr handle, sbyte data);
[DllImport(efl.Libs.CustomExports)]
[DllImport(efl.Libs.CustomExports)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
+ internal static extern bool eina_value_container_set_wrapper_ptr(IntPtr handle, int index, IntPtr value);
+
+ [DllImport(efl.Libs.CustomExports)]
+ [return: MarshalAsAttribute(UnmanagedType.U1)]
internal static extern bool eina_value_container_set_wrapper_uchar(IntPtr handle, int index, byte value);
[DllImport(efl.Libs.CustomExports)]
[DllImport(efl.Libs.Eina)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
+ internal static extern bool eina_value_optional_pset(IntPtr handle, IntPtr subtype, ref IntPtr value);
+
+ [DllImport(efl.Libs.Eina)]
+ [return: MarshalAsAttribute(UnmanagedType.U1)]
internal static extern bool eina_value_optional_pset(IntPtr handle, IntPtr subtype, IntPtr value);
[DllImport(efl.Libs.Eina)]
// Error
[DllImport(efl.Libs.CustomExports)]
internal static extern IntPtr type_error();
+
+ // Error
+ [DllImport(efl.Libs.CustomExports)]
+ internal static extern IntPtr type_object();
}
}
Optional,
/// <summary>Error values.</summary>
Error,
+ Object,
/// <summary>Empty values.</summary>
Empty,
}
return val == ValueType.Error;
}
+ public static bool IsObject(this ValueType val)
+ {
+ return val == ValueType.Object;
+ }
+
/// <summary>Returns the Marshal.SizeOf for the given ValueType native structure.</summary>
public static int MarshalSizeOf(this ValueType val)
{
ManagedToNative.Add(ValueType.Error, type_error());
NativeToManaged.Add(type_error(), ValueType.Error);
+ ManagedToNative.Add(ValueType.Object, type_object());
+ NativeToManaged.Add(type_object(), ValueType.Object);
+
ManagedToNative.Add(ValueType.Empty, IntPtr.Zero);
NativeToManaged.Add(IntPtr.Zero, ValueType.Empty);
return b;
}
+ // Efl.Object conversions are made explicit to avoid ambiguity between
+ // Set(Efl.Object) and Set(Value) when dealing with classes derived from
+ // Efl.Object.
+ /// <summary>Explicit conversion from EFL objects.</summary>
+ public static explicit operator Value(Efl.Object obj)
+ {
+ var v = new Eina.Value(ValueType.Object);
+ if (!v.Set(obj))
+ {
+ throw new InvalidOperationException("Couldn't set value.");
+ }
+ return v;
+ }
+
+ /// <summary>Explicit conversion from Value to Efl.Objects.</summary>
+ public static explicit operator Efl.Object(Value v)
+ {
+ Efl.Object obj;
+ if (!v.Get(out obj))
+ {
+ throw new InvalidOperationException("Couldn't get value.");
+ }
+
+ return obj;
+ }
+
/// <summary>Creates an Value instance from a given array description.</summary>
private static Value FromArrayDesc(Eina.EinaNative.Value_Array arrayDesc)
{
return eina_value_set_wrapper_int(this.Handle, error_code);
}
+ /// <summary>Stores the given object.</summary>
+ public bool Set(Efl.Object value)
+ {
+ // FIXME Implement me
+ SanityChecks();
+
+ if (this.Optional)
+ {
+ IntPtr ptr = value.NativeHandle;
+ return eina_value_optional_pset(this.Handle,
+ ValueTypeBridge.GetNative(ValueType.Object),
+ ref ptr);
+ }
+ return eina_value_set_wrapper_ptr(this.Handle, value.NativeHandle);
+ }
+
/// <summary>Stores the given value into this value. The target value must be an optional.</summary>
public bool Set(Value value)
{
return ret;
}
+ /// <summary>Gets the currently stored value as an <see cref="Efl.Object"/>.</summary>
+ public bool Get(out Efl.Object obj)
+ {
+ // FIXME Implement me
+ SanityChecks();
+ IntPtr ptr;
+ bool ret;
+
+ if (this.Optional)
+ {
+ ret = eina_value_optional_pget(this.Handle, out ptr);
+ }
+ else
+ {
+ ret = eina_value_get_wrapper(this.Handle, out ptr);
+ }
+
+ if (ret)
+ {
+ obj = (Efl.Object) Efl.Eo.Globals.CreateWrapperFor(ptr);
+ }
+ else
+ {
+ obj = null;
+ }
+
+ return ret;
+ }
+
+
/// <summary>Gets the currently stored value as an complex (e.g. container) Eina.Value.</summary>
public bool Get(out Value value)
{
string x = Convert.ToString(o);
return eina_value_container_append_wrapper_string(this.Handle, x);
}
+ case ValueType.Object:
+ {
+ var x = (Efl.Object) o;
+ return eina_value_container_append_wrapper_ptr(this.Handle, x.NativeHandle);
+ }
}
return false;
eina_value_container_get_wrapper(this.Handle, i, out ptr);
return Eina.StringConversion.NativeUtf8ToManagedString(ptr);
}
+ case ValueType.Object:
+ {
+ IntPtr ptr = IntPtr.Zero;
+ eina_value_container_get_wrapper(this.Handle, i, out ptr);
+ return Efl.Eo.Globals.CreateWrapperFor(ptr);
+ }
default:
throw new InvalidOperationException("Subtype not supported.");
eina_value_container_set_wrapper_string(this.Handle, i, x);
break;
}
+ case ValueType.Object:
+ {
+ Efl.Object x = (Efl.Object)value;
+ eina_value_container_set_wrapper_ptr(this.Handle, i, x.NativeHandle);
+ break;
+ }
}
}
}
};
string key = "_EFL_UI_EVENT_SCROLL_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_UP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_UP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeUpEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_UP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_DOWN";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeDownEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_DOWN";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_LEFT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeLeftEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_LEFT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_EDGE_RIGHT";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnEdgeRightEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_EDGE_RIGHT";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollAnimStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStartEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
};
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
+ AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
}
}
lock (eventLock)
{
string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- RemoveNativeEventHandler(efl.Libs.Efl, key, value);
+ RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
}
}
}
public void OnScrollDragStopEvt(EventArgs e)
{
var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
- IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
+ IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
if (desc == IntPtr.Zero)
{
Eina.Log.Error($"Failed to get native event {key}");
x = default(double); y = default(double);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetGravity(out x, out y);
+ ((IInterfaceScrollable)ws.Target).GetGravity(out x, out y);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetGravity(x, y);
+ ((IInterfaceScrollable)ws.Target).SetGravity(x, y);
}
catch (Exception e)
{
horiz = default(bool); vert = default(bool);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetBounceAllow(out horiz, out vert);
+ ((IInterfaceScrollable)ws.Target).GetBounceAllow(out horiz, out vert);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetBounceAllow(horiz, vert);
+ ((IInterfaceScrollable)ws.Target).SetBounceAllow(horiz, vert);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetWheelDisabled();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetWheelDisabled();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetWheelDisabled(disabled);
+ ((IInterfaceScrollable)ws.Target).SetWheelDisabled(disabled);
}
catch (Exception e)
{
Efl.Ui.ScrollBlock _ret_var = default(Efl.Ui.ScrollBlock);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetMovementBlock();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetMovementBlock();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetMovementBlock(block);
+ ((IInterfaceScrollable)ws.Target).SetMovementBlock(block);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetMomentumAnimatorDisabled();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetMomentumAnimatorDisabled();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetMomentumAnimatorDisabled(disabled);
+ ((IInterfaceScrollable)ws.Target).SetMomentumAnimatorDisabled(disabled);
}
catch (Exception e)
{
hbar = default(Elm.Scroller.Policy); vbar = default(Elm.Scroller.Policy);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetPolicy(out hbar, out vbar);
+ ((IInterfaceScrollable)ws.Target).GetPolicy(out hbar, out vbar);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPolicy(hbar, vbar);
+ ((IInterfaceScrollable)ws.Target).SetPolicy(hbar, vbar);
}
catch (Exception e)
{
x = default(int); y = default(int); w = default(int); h = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetContentRegion(out x, out y, out w, out h);
+ ((IInterfaceScrollable)ws.Target).GetContentRegion(out x, out y, out w, out h);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetContentRegion(x, y, w, h);
+ ((IInterfaceScrollable)ws.Target).SetContentRegion(x, y, w, h);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetContentEvents();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetContentEvents();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetContentEvents(repeat_events);
+ ((IInterfaceScrollable)ws.Target).SetContentEvents(repeat_events);
}
catch (Exception e)
{
x = default(int); y = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetPageSize(out x, out y);
+ ((IInterfaceScrollable)ws.Target).GetPageSize(out x, out y);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPageSize(x, y);
+ ((IInterfaceScrollable)ws.Target).SetPageSize(x, y);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetBounceAnimatorDisabled();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetBounceAnimatorDisabled();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetBounceAnimatorDisabled(disabled);
+ ((IInterfaceScrollable)ws.Target).SetBounceAnimatorDisabled(disabled);
}
catch (Exception e)
{
page_limit_h = default(int); page_limit_v = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetPageScrollLimit(out page_limit_h, out page_limit_v);
+ ((IInterfaceScrollable)ws.Target).GetPageScrollLimit(out page_limit_h, out page_limit_v);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPageScrollLimit(page_limit_h, page_limit_v);
+ ((IInterfaceScrollable)ws.Target).SetPageScrollLimit(page_limit_h, page_limit_v);
}
catch (Exception e)
{
horiz = default(bool); vert = default(bool);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetPageSnapAllow(out horiz, out vert);
+ ((IInterfaceScrollable)ws.Target).GetPageSnapAllow(out horiz, out vert);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPageSnapAllow(horiz, vert);
+ ((IInterfaceScrollable)ws.Target).SetPageSnapAllow(horiz, vert);
}
catch (Exception e)
{
pagerel_h = default(double); pagerel_v = default(double); pagesize_h = default(int); pagesize_v = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetPaging(out pagerel_h, out pagerel_v, out pagesize_h, out pagesize_v);
+ ((IInterfaceScrollable)ws.Target).GetPaging(out pagerel_h, out pagerel_v, out pagesize_h, out pagesize_v);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPaging(pagerel_h, pagerel_v, pagesize_h, pagesize_v);
+ ((IInterfaceScrollable)ws.Target).SetPaging(pagerel_h, pagerel_v, pagesize_h, pagesize_v);
}
catch (Exception e)
{
Elm.Scroller.SingleDirection _ret_var = default(Elm.Scroller.SingleDirection);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetSingleDirection();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetSingleDirection();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetSingleDirection(single_dir);
+ ((IInterfaceScrollable)ws.Target).SetSingleDirection(single_dir);
}
catch (Exception e)
{
x = default(int); y = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetStepSize(out x, out y);
+ ((IInterfaceScrollable)ws.Target).GetStepSize(out x, out y);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetStepSize(x, y);
+ ((IInterfaceScrollable)ws.Target).SetStepSize(x, y);
}
catch (Exception e)
{
loop_h = default(bool); loop_v = default(bool);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetContentLoop(out loop_h, out loop_v);
+ ((IInterfaceScrollable)ws.Target).GetContentLoop(out loop_h, out loop_v);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetContentLoop(loop_h, loop_v);
+ ((IInterfaceScrollable)ws.Target).SetContentLoop(loop_h, loop_v);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollUpCb(scroll_up_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollUpCb(scroll_up_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetHbarDragCb(hbar_drag_cb);
+ ((IInterfaceScrollable)ws.Target).SetHbarDragCb(hbar_drag_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetDragStartCb(drag_start_cb);
+ ((IInterfaceScrollable)ws.Target).SetDragStartCb(drag_start_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollStartCb(scroll_start_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollStartCb(scroll_start_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetFreeze(freeze);
+ ((IInterfaceScrollable)ws.Target).SetFreeze(freeze);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetContentViewportResizeCb(viewport_resize_cb);
+ ((IInterfaceScrollable)ws.Target).SetContentViewportResizeCb(viewport_resize_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollLeftCb(scroll_left_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollLeftCb(scroll_left_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetVbarPressCb(vbar_press_cb);
+ ((IInterfaceScrollable)ws.Target).SetVbarPressCb(vbar_press_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetHbarPressCb(hbar_press_cb);
+ ((IInterfaceScrollable)ws.Target).SetHbarPressCb(hbar_press_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetHbarUnpressCb(hbar_unpress_cb);
+ ((IInterfaceScrollable)ws.Target).SetHbarUnpressCb(hbar_unpress_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetDragStopCb(drag_stop_cb);
+ ((IInterfaceScrollable)ws.Target).SetDragStopCb(drag_stop_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollStopCb(scroll_stop_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollStopCb(scroll_stop_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetExternPan(pan);
+ ((IInterfaceScrollable)ws.Target).SetExternPan(pan);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPageChangeCb(page_change_cb);
+ ((IInterfaceScrollable)ws.Target).SetPageChangeCb(page_change_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetHold(hold);
+ ((IInterfaceScrollable)ws.Target).SetHold(hold);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetAnimateStartCb(animate_start_cb);
+ ((IInterfaceScrollable)ws.Target).SetAnimateStartCb(animate_start_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollDownCb(scroll_down_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollDownCb(scroll_down_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetPageRelative(h_pagerel, v_pagerel);
+ ((IInterfaceScrollable)ws.Target).SetPageRelative(h_pagerel, v_pagerel);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollCb(scroll_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollCb(scroll_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetAnimateStopCb(animate_stop_cb);
+ ((IInterfaceScrollable)ws.Target).SetAnimateStopCb(animate_stop_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetContentMinLimitCb(min_limit_cb);
+ ((IInterfaceScrollable)ws.Target).SetContentMinLimitCb(min_limit_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollRightCb(scroll_right_cb);
+ ((IInterfaceScrollable)ws.Target).SetScrollRightCb(scroll_right_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetScrollableContent(content);
+ ((IInterfaceScrollable)ws.Target).SetScrollableContent(content);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetEdgeLeftCb(edge_left_cb);
+ ((IInterfaceScrollable)ws.Target).SetEdgeLeftCb(edge_left_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetVbarDragCb(vbar_drag_cb);
+ ((IInterfaceScrollable)ws.Target).SetVbarDragCb(vbar_drag_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetVbarUnpressCb(vbar_unpress_cb);
+ ((IInterfaceScrollable)ws.Target).SetVbarUnpressCb(vbar_unpress_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetEdgeBottomCb(edge_bottom_cb);
+ ((IInterfaceScrollable)ws.Target).SetEdgeBottomCb(edge_bottom_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetEdgeRightCb(edge_right_cb);
+ ((IInterfaceScrollable)ws.Target).SetEdgeRightCb(edge_right_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetEdgeTopCb(edge_top_cb);
+ ((IInterfaceScrollable)ws.Target).SetEdgeTopCb(edge_top_cb);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetObjects(edje_object, hit_rectangle);
+ ((IInterfaceScrollable)ws.Target).SetObjects(edje_object, hit_rectangle);
}
catch (Exception e)
{
pagenumber_h = default(int); pagenumber_v = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetLastPage(out pagenumber_h, out pagenumber_v);
+ ((IInterfaceScrollable)ws.Target).GetLastPage(out pagenumber_h, out pagenumber_v);
}
catch (Exception e)
{
pagenumber_h = default(int); pagenumber_v = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetCurrentPage(out pagenumber_h, out pagenumber_v);
+ ((IInterfaceScrollable)ws.Target).GetCurrentPage(out pagenumber_h, out pagenumber_v);
}
catch (Exception e)
{
x = default(int); y = default(int); w = default(int); h = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetContentViewportGeometry(out x, out y, out w, out h);
+ ((IInterfaceScrollable)ws.Target).GetContentViewportGeometry(out x, out y, out w, out h);
}
catch (Exception e)
{
w = default(int); h = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetContentSize(out w, out h);
+ ((IInterfaceScrollable)ws.Target).GetContentSize(out w, out h);
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetItemLoopEnabled();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetItemLoopEnabled();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetItemLoopEnabled(enable);
+ ((IInterfaceScrollable)ws.Target).SetItemLoopEnabled(enable);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetContentPos(x, y, sig);
+ ((IInterfaceScrollable)ws.Target).SetContentPos(x, y, sig);
}
catch (Exception e)
{
x = default(int); y = default(int);
try
{
- ((IInterfaceScrollableConcrete)ws.Target).GetContentPos(out x, out y);
+ ((IInterfaceScrollable)ws.Target).GetContentPos(out x, out y);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).ShowPage(pagenumber_h, pagenumber_v);
+ ((IInterfaceScrollable)ws.Target).ShowPage(pagenumber_h, pagenumber_v);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).RegionBringIn(x, y, w, h);
+ ((IInterfaceScrollable)ws.Target).RegionBringIn(x, y, w, h);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).PageBringIn(pagenumber_h, pagenumber_v);
+ ((IInterfaceScrollable)ws.Target).PageBringIn(pagenumber_h, pagenumber_v);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).ShowContentRegion(x, y, w, h);
+ ((IInterfaceScrollable)ws.Target).ShowContentRegion(x, y, w, h);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).ContentMinLimit(w, h);
+ ((IInterfaceScrollable)ws.Target).ContentMinLimit(w, h);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetWantedRegion(x, y);
+ ((IInterfaceScrollable)ws.Target).SetWantedRegion(x, y);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).CustomPanPosAdjust(_in_x, _in_y);
+ ((IInterfaceScrollable)ws.Target).CustomPanPosAdjust(_in_x, _in_y);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).FocusManagerCreate(root);
+ _ret_var = ((IInterfaceScrollable)ws.Target).FocusManagerCreate(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetManagerFocus();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetManagerFocus();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetManagerFocus(focus);
+ ((IInterfaceScrollable)ws.Target).SetManagerFocus(focus);
}
catch (Exception e)
{
Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetRedirect();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetRedirect();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetRedirect(redirect);
+ ((IInterfaceScrollable)ws.Target).SetRedirect(redirect);
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetBorderElements();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetBorderElements();
}
catch (Exception e)
{
Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetViewportElements(_in_viewport);
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetViewportElements(_in_viewport);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).GetRoot();
+ _ret_var = ((IInterfaceScrollable)ws.Target).GetRoot();
}
catch (Exception e)
{
bool _ret_var = default(bool);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).SetRoot(root);
+ _ret_var = ((IInterfaceScrollable)ws.Target).SetRoot(root);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).Move(direction);
+ _ret_var = ((IInterfaceScrollable)ws.Target).Move(direction);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).MoveRequest(direction, child, logical);
+ _ret_var = ((IInterfaceScrollable)ws.Target).MoveRequest(direction, child, logical);
}
catch (Exception e)
{
Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).RequestSubchild(root);
+ _ret_var = ((IInterfaceScrollable)ws.Target).RequestSubchild(root);
}
catch (Exception e)
{
Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).Fetch(child);
+ _ret_var = ((IInterfaceScrollable)ws.Target).Fetch(child);
}
catch (Exception e)
{
Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
try
{
- _ret_var = ((IInterfaceScrollableConcrete)ws.Target).LogicalEnd();
+ _ret_var = ((IInterfaceScrollable)ws.Target).LogicalEnd();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).ResetHistory();
+ ((IInterfaceScrollable)ws.Target).ResetHistory();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).PopHistoryStack();
+ ((IInterfaceScrollable)ws.Target).PopHistoryStack();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).SetupOnFirstTouch(direction, entry);
+ ((IInterfaceScrollable)ws.Target).SetupOnFirstTouch(direction, entry);
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).FreezeDirtyLogic();
+ ((IInterfaceScrollable)ws.Target).FreezeDirtyLogic();
}
catch (Exception e)
{
try
{
- ((IInterfaceScrollableConcrete)ws.Target).DirtyLogicUnfreeze();
+ ((IInterfaceScrollable)ws.Target).DirtyLogicUnfreeze();
}
catch (Exception e)
{
public static byte class_initializer_call(IntPtr klass, System.Type type)
{
Eina.Log.Debug($"called with 0x{klass.ToInt64():x} {type}");
- Efl.Eo.NativeClass nativeClass = GetNativeClass(type.BaseType);
+ var derived = type.BaseType;
+ Efl.Eo.NativeClass nativeClass = GetNativeClass(derived);
+
+ while (nativeClass == null)
+ {
+ derived = derived.BaseType;
+ if (derived == null)
+ break;
+ nativeClass = GetNativeClass(derived);
+ }
if (nativeClass != null)
{
projects / platform / core / csapi / tizenfx.git / commitdiff