Summary:
The LoadFunctionPointer relied on leaks of NativeModules by not
disposing them. Instead do direct loading without instantiating
unnecessary objects.
Reviewers: lauromoura, woohyun, brunobelo
Reviewed By: lauromoura
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10258
Summary:
Instead of receiving a callback that compares two intptrs (which is
still used internally), expose a more C#-friendly delegate which is
wrapped into the native one.
Test Plan: run test suite
Reviewers: felipealmeida, segfaultxavi, brunobelo
Reviewed By: felipealmeida
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10253
Summary:
Sometimes, valid Eo objects of private classes can be returned from
methods. Currently we try to wrap in a minimal `Efl.Object` instance,
but as it is an abstract class, we can't instantiate directly.
This commits adds a dummy `Efl.ObjectRealized` to be instantiated when
wrapping such classes alongside a test case.
Fixes: T8258
Reviewers: felipealmeida, brunobelo, segfaultxavi, Jaehyun_Cho
Reviewed By: brunobelo
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10101
Summary:
C# language binding generates C# method name beginning with verb by
checking verb list in name_helpers.hh.
Some verbs used in eo method are missing in the current verb list. So
they are added into the verb list.
In this scheme, there is a problem that some words can be used as a verb
in some methods but they also can be used as a noun in other methods.
(e.g. drag_start as a verb / cursor_word_start as a noun)
So "start" and "scroll" are not added to verb list in this patch.
To resolve the above problem, we may need a new eo syntax to rename or
reverse the name in language bindings.
Test Plan: Check C# method names in .eo.cs files if the name begins with verb.
Reviewers: felipealmeida, SanghyeonLee, woohyun, Jaehyun_Cho, segfaultxavi
Reviewed By: segfaultxavi
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10001
Summary:
The C function `eina_hash_del_by_data` requires the same value that was
passed to the `add` function. As C# hashes store stuff through pointers
due to marshalling, this makes it hard to pass the same pointer for it.
So this functionality is implemented at C# level instead of relying on
the native function directly.
Fixes T8198
Thanks to @brunobelo and @singh.amitesh for the test case.
Reviewers: singh.amitesh, felipealmeida, brunobelo
Reviewed By: brunobelo
Subscribers: cedric, #reviewers, #committers, singh.amitesh, brunobelo
Tags: #efl
Maniphest Tasks: T8198
Differential Revision: https://phab.enlightenment.org/D9853
Summary:
Eolian allows non-public members in interfaces and mixins (usually
@protected). As both kinds are converted to C# interfaces, this
causes problem as non-public members are forbidden in C# interfaces.
This commit changes eolian_mono by removing those members from the C#
interfaces. If a generated class implements the interface, the method is
generated as if it were a protected member of the class directly.
For mixed properties like `Efl.Io.Reader.CanRead { get; set @protected; }`,
the interface has only the public getter and the the implementing class has both
the public getter and the protected setter.
With this, C# devs won't be able to directly implement protected Eo
methods from interfaces. (But this really does not make sense from the
C# point of view).
ref T7494
Reviewers: segfaultxavi, felipealmeida, YOhoho
Reviewed By: YOhoho
Subscribers: cedric, brunobelo, Jaehyun_Cho, #reviewers, woohyun, #committers
Tags: #efl
Maniphest Tasks: T7494
Differential Revision: https://phab.enlightenment.org/D9800
Summary:
WIN32 should use a allocator and deallocator different from EFL, sometimes, when
freeing a pointer, it should use win32_free. To stardardize, A custommarshaler
is used to fix this problem.
Fixes T8201
Reviewers: lauromoura, felipealmeida
Reviewed By: lauromoura
Subscribers: cedric, brunobelo, felipealmeida, #reviewers, lauromoura, #committers
Tags: #efl
Maniphest Tasks: T8201
Differential Revision: https://phab.enlightenment.org/D9842
Summary:
Duplicated interface's NativeMethods code will be removed. they are called in
`GetInterfaces`.
Size of efl_mono.dll
6,587,392 bytes(6.6MB) -> 4,112,384 bytes (4.1MB)
Test Plan: ninja test
Reviewers: felipealmeida, lauromoura, vitor.sousa
Reviewed By: lauromoura
Subscribers: cedric, #reviewers, woohyun, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9752
Summary:
SetKeyValue adds a value object associated with a key object to hash
table.
GetKeyValue returns a value object associated with a key object from
hash table.
Reviewers: felipealmeida, lauromoura, vitor.sousa, woohyun, cedric
Subscribers: zmike, bu5hm4n, segfaultxavi, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9622
Summary:
C#'s factory must inherit from `LayoutFactory` so we can access its
implementation of `FactoryBind`.
Depends on D9759 to avoid test failure on PropertyBound events.
Reviewers: felipealmeida, cedric, SanghyeonLee
Reviewed By: SanghyeonLee
Subscribers: #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9760
Summary:
Add the -p command to eolian to create a class as a partial
class. Create a list in meson build of Eolian files that should be
built with partial classes.
This allows creating more specific method overloads for C#, manually,
by generating the class as partial and adding in manual binding the
partial class with the new methods and properties.
T8034
Reviewers: segfaultxavi, lauromoura, woohyun, Jaehyun_Cho
Reviewed By: lauromoura
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9690
Summary:
This commit makes parts that implement `Efl.IContent` use BindFactory
instead of property binding.
```
var factory = new Efl.Ui.ItemFactory<Efl.Ui.ListDefaultItem>();
var iconFactory = new Efl.Ui.ImageFactory(null);
iconFactory.PropertyBind("filename", "modelProperty");
factory.IconPart().BindFactory(iconFactory);
```
Fixes T7628
Reviewers: cedric, felipealmeida, SanghyeonLee
Reviewed By: felipealmeida
Tags: #efl
Maniphest Tasks: T7628
Differential Revision: https://phab.enlightenment.org/D9653
Summary:
Parts binding will follow a similar approach to regular property
binding:
`var error = factory.PartName().PropertyName().Bind(modelProperty);`
* Changed both `Bind()` overloads to return the error code from
`efl_ui_property_bind`
* Also properties from interfaces implemented didn't have their `Bindable`
wrapper methds available.
Depends on D9563
Reviewers: felipealmeida, cedric, SanghyeonLee, woohyun
Reviewed By: cedric
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9564
Summary:
`eolian_mono` now considers the implicit ownership of value types in arrays and
lists when generating ownership flags.
Also, update manual bindings for arrays and lists to no longer free elements
in the `Dispose` method when the container has ownership of the elements
but C# itself does not have ownership of the container; the elements will be
freed by whoever owns the container.
Modifying and removing elements will still free them though.
Re-enabled unit tests that required ownership of value type elements.
Reviewers: felipealmeida, q66, vitor.sousa
Reviewed By: felipealmeida
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9457
Summary:
It uses a custom marshaler and a helper boxing class to convert between
the managed enum values and the native Eina_Value_Type pointers.
To be used by future MVVM machinery.
Reviewers: vitor.sousa, felipealmeida
Reviewed By: vitor.sousa
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9443
Summary:
`Efl.Event` became a builtin type that is no longer declared in `efl_object.eo`,
and therefore it is no longer automatically generated in EFL#.
Given that, we define a struct manually to reflect the memory layout of the
native struct.
Containers of value types are now allowed in eolian, so tests that were disabled
because of the restriction on `ptr` were re-enabled using the plain type.
But since these containers have just arrived, handling of ownership for value
types is currently undefined in bindings.
Hence, tests that used `ptr(int) @owned` as elements were left disable.
This will be solved in a future patch.
`void_pr` is now deprecated, so we remove it from tests also.
Reviewers: q66, segfaultxavi, lauromoura, felipealmeida
Reviewed By: lauromoura
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9417
Summary:
When creating a new Value with any IEnumerable of a supported type, the IEnumerable
will be copied into an Eina.Value of type EINA_VALUE_ARRAY_TYPE.
Similarly, `Unwrap()` on a Eina.Value container will create a new
System.Collections.List<T> and return it.
Depends on D9272
Reviewers: felipealmeida, vitor.sousa, segfaultxavi
Reviewed By: vitor.sousa
Subscribers: cedric, #reviewers, #committers
Tags: #efl, #expertise_solutions
Differential Revision: https://phab.enlightenment.org/D9273
Summary:
The user can construct an `Eina.Value` from a plain C# `object`, using
reflection to get the correct type of object and construct the correct
underlying C value.
Also added the `Unwrap()` method to return a C# object representing the
wrapped value.
Both operations are useful when using `Eina.Value` to
Get/Set values from `PropertyInfo` targets as in
```
var v = new Eina.Value(propInfo.GetValue(sourceObj));
...
propInfo.SetValue(targetObj, v.Unwrap());
```
Currently, containers are not supported. It will be added in a following
commit.
Depends on D9270
Reviewers: felipealmeida, vitor.sousa, segfaultxavi
Reviewed By: vitor.sousa
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9272
Summary:
Attributes to be used by the API export tool. For end users, no changes
in the public API (except for a new attribute in generated classes).
Also simplifies constructor forwarding by not needing to pass the type
of the first "generated" class to compare.
Currently only automatically generated items are tagged.
Depends: D9259
Reviewers: vitor.sousa, felipealmeida
Reviewed By: vitor.sousa
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9270
Summary:
Some parameter names, tag names and cref identifiers in the documentation were
incorrect and causing warnings during compilation.
There were also warnings related with missing documentation in publicly
visible elements in the manual binding.
This commit fixes these incorrections and adds documentation to the manual
binding in order to solve these compilation warnings.
Warnings related with missing documentation in `.eo` files are still present.
Test Plan: Just compile with mono binding.
Reviewers: lauromoura, felipealmeida, segfaultxavi
Reviewed By: segfaultxavi
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9243
Assigning a method directly to a field expecting a delegate creates a
delegate on the fly. This delegate can be collected normally as any
collectable object. In dotnet the GC is more aggressive, causing this
delegate to be collected and C trying to call an invalid function.
To avoid this, we create a static delegate that will be passed to C. Its
lifetime will be tied to the static method it wraps.
Summary:
Encapsulate some parts of EoWrapper making them less accessible to lib users.
This can avoid unnecessary and risky usage of code that is only intended for
internal usage.
`inherited` field was made private and renamed to `generated`. Now its value
can only be obtained through the `IsGeneratedBindingClass` property.
`handle` field was made private.
`eventLock` was renamed to `eflBindingEventLock`
`ConstructingHandle` property set was made private.
Constructors that are used to create new EFL# managed objects by wrapping a
preexisting eo handle now receive a specific struct wrapping the handle pointer.
This can avoid faulty interactions with the Reflection engine used only for
generated classes that implement this constructor.
Test Plan: meson test
Reviewers: lauromoura, felipealmeida, YOhoho
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9212
Summary:
Both C strings and eina stringshares are bound as regular strings in EFL#, as
working directly with these types would demand unnecessary hassle from the user
viewpoint.
But for eina containers this distinction is important, and since C# generics
do not provide a convenient way of dealing with the same type requiring a
different management based on some other condition (at least not without
compromising the usability for other types), we added a simple `System.String`
wrapper named `Eina.Stringshare` that works as a placeholder for signaling
this distinction.
Working with this class should be transparent in most use cases because it
converts to and from `System.String` implicitly.
It also implements equality/inequality methods for easier comparison with
strings and other stringshare objects.
Add new methods and a new container element trait for dealing specifically
with `Eina_Stringshare` elements.
Adapt eolian_mono to identify and generate the proper placeholder in methods
that require stringshare containers.
Remove some direct uses of DllImport-ed functions in favor of more flexible
manual binding methods.
Move `Eina.Stringshare` DllImport directives to a static class named
`NativeMethods`, in accordance with the code design warning CA1060.
Also add a TODO comment to move all other DllImport directives to this class.
Change parameter of the method `Efl.Csharp.Application.OnInitialize` from
`Eina.Array<System.String>` to `string[]`.
This will make this API more similar with the default C# way of receiving
command line arguments.
Add tests for containers storing stringshare elements.
Reviewers: felipealmeida, lauromoura, segfaultxavi, bu5hm4n
Reviewed By: lauromoura
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9178
Summary:
With this commit it is now possible for a class that inherits from a C# binding
class to be instantiated from native C code. It only has to provide a
constructor that receives an `Efl.Eo.EoWrapper.ConstructingHandle` struct,
and which calls the base binding constructor passing it.
For example:
`private Type(ConstructingHandle ch) : base(ch) {}`.
Add some test files to validate the proper behavior of this feature.
Add some small fixes in generation contexts in order to properly
generate base constructors.
Depends on D9070
Test Plan: `meson test` and `make check`
Reviewers: lauromoura, felipealmeida, segfaultxavi, woohyun, YOhoho
Reviewed By: YOhoho
Subscribers: YOhoho, cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9071
Summary:
Values returned from C# Then callbacks must release ownership of the
underlying native value, so Eina code can clean it up nicely and avoid
the Wrapper flushing it early.
The same issue applied to the Async wrappers. In this case the value
passed as the Task parameter could be released by an `using` block
awaiting the value.
Also Future creation was then-ing the wrong handle.
Also add better exception messages.
Reviewers: vitor.sousa, felipealmeida
Reviewed By: vitor.sousa
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9197
Summary:
Iterator and Accessors are views only, not owning the data they point
to.
Also updated the tests by handling some test data that were leaking.
Fixes T8036
Reviewers: vitor.sousa, felipealmeida
Reviewed By: vitor.sousa
Subscribers: cedric, #reviewers, #committers, segfaultxavi, q66
Tags: #efl
Maniphest Tasks: T8036
Differential Revision: https://phab.enlightenment.org/D9189
Summary:
C# `Eina.Value` now has builtin support for `EINA_VALUE_TYPE_OBJECT`.
To avoid ambiguity with the `Set` method overloads, explicit casting
operators were used for wrapping/unwrapping `Efl.Object` instead of
implicit ones like for other value types.
Thus, to initialize an `Eina.Value` from an object, you can use the
following:
`var v = (Eina.Value)myObj;`
Reviewers: felipealmeida, vitor.sousa, segfaultxavi, Jaehyun_Cho
Reviewed By: Jaehyun_Cho
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9164
Summary:
When it creates multilevel class of NativeClass, internal c function is not
called because eo vtables aren't created
Test Plan:
Check "MyBox2 UpdateLayout" printed.
```
//mcs test_box.cs -out:test_box.exe `pkg-config --libs efl-mono`
//mono test_box.exe
using System;
public class MyBox2 : MyBox
{
public MyBox2(Efl.Object parent, string style = null) : base(parent, style)
{
}
public override void UpdateLayout()
{
Eina.Log.Error("MyBox2 UpdateLayout");
base.UpdateLayout();
}
}
public class MyBox : Efl.Ui.Box
{
public MyBox(Efl.Object parent, string style = null) : base(parent, style)
{
}
public override void UpdateLayout()
{
Eina.Log.Error("MyBox UpdateLayout");
base.UpdateLayout();
}
}
public class Example : Efl.Csharp.Application
{
protected override void OnInitialize(Eina.Array<System.String> args)
{
Efl.Ui.Win win = new Efl.Ui.Win(Efl.App.AppMain);
var box = new MyBox(win);
box.SetHintSizeMin(new Eina.Size2D(360, 240));
win.SetContent(box);
var box2 = new MyBox2(win);
box2.SetHintSizeMin(new Eina.Size2D(360, 240));
box2.Pack(box);
var button = new Efl.Ui.Button(box);
button.SetText("Click");
button.ClickedEvt += (object sender, Efl.Ui.IClickableClickedEvt_Args e) =>
{
box.CalculateGroup();
box2.CalculateGroup();
};
box.Pack(button);
}
public static void Main()
{
var example = new Example();
example.Launch();
}
}
```
Reviewers: segfaultxavi, vitor.sousa, felipealmeida, lauromoura, woohyun, Jaehyun_Cho
Reviewed By: Jaehyun_Cho
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9079