<< scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n"
<< scope_tab << "/// <summary>Initializes a new instance of the <see cref=\"" << interface_name << "\"/> class.\n"
<< scope_tab << "/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>\n"
+ << scope_tab << "/// <param name=\"wh\">The native pointer to be wrapped.</param>\n"
<< scope_tab << "private " << concrete_name << "(Efl.Eo.Globals.WrappingHandle wh) : base(wh)\n"
<< scope_tab << "{\n"
<< scope_tab << "}\n\n"
<< scope_tab << "}\n\n"
<< scope_tab << "/// <summary>Initializes a new instance of the <see cref=\"" << inherit_name << "\"/> class.\n"
<< scope_tab << "/// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>\n"
- << scope_tab << "/// <param name=\"raw\">The native pointer to be wrapped.</param>\n"
+ << scope_tab << "/// <param name=\"wh\">The native pointer to be wrapped.</param>\n"
<< scope_tab << "protected " << inherit_name << "(Efl.Eo.Globals.WrappingHandle wh) : base(wh)\n"
<< scope_tab << "{\n"
<< scope_tab << "}\n\n"
/// </remarks>
public class Stringshare : IEquatable<Stringshare>, IEquatable<string>
{
- /// <sumary>
+ /// <summary>
/// Main constructor. Wrap the given string.
/// Have private acess to avoid wrapping a null reference,
/// use convertion or the factory method to create a new instance.
- /// <see cref="Stringshare.Create(string s)"/>
- /// <see cref="Stringshare.operator Stringshare(string s)"/>
- /// </sumary>
+ /// <see cref="Create(string)"/>
+ /// <see cref="implicit operator Stringshare(string)"/>
+ /// </summary>
private Stringshare(string s)
{
Str = s;
}
- /// <sumary>
+ /// <summary>
/// Auto-implemented property that holds the wrapped string value.
- /// </sumary>
+ /// </summary>
public string Str { get; private set; }
- /// <sumary>
+ /// <summary>
/// Factory method to instantiate a new object.
/// Get a wrappper for the given string or a null reference if the given
/// string reference is also null.
- /// <seealso cref="Stringshare.operator Stringshare(string s)"/>
- /// </sumary>
+ /// <seealso cref="implicit operator Stringshare(string)"/>
+ /// </summary>
/// <returns>
/// A new instance wrapping the given string, or a null reference if
/// the given string reference is also null.
return new Stringshare(s);
}
- /// <sumary>
+ /// <summary>
/// Implicit convertion to string.
- /// </sumary>
+ /// </summary>
public static implicit operator string(Stringshare ss)
{
if (ReferenceEquals(null, ss))
return ss.Str;
}
- /// <sumary>
+ /// <summary>
/// Implicit convertion from string to Stringshare.
- /// </sumary>
+ /// </summary>
/// <remarks>
/// Note that this method can be used to create an instance of this class,
/// either via an explicit cast or an implicit convertion.
- /// <seealso cref="Stringshare.Create(string s)"/>
+ /// <seealso cref="Create(string)"/>
/// </remarks>
public static implicit operator Stringshare(string s)
{
return new Stringshare(s);
}
- /// <sumary>
+ /// <summary>
/// Check two Stringshare objects for equality.
- /// </sumary>
+ /// </summary>
/// <returns>
/// True if both wrapped strings have the same content or if both
/// references are null, false otherwise.
}
- /// <sumary>
+ /// <summary>
/// Check two Stringshare objects for inequality.
- /// </sumary>
+ /// </summary>
/// <returns>
/// True if the wrapped strings have different content or if one reference is null
/// and the other is not, false otherwise.
return !(ss1 == ss2);
}
- /// <sumary>
+ /// <summary>
/// Returns the wrapped string.
- /// <seealso cref="Stringshare.Str"/>
- /// <seealso cref="Stringshare.Get()"/>
- /// </sumary>
+ /// <seealso cref="Str"/>
+ /// <seealso cref="Get()"/>
+ /// </summary>
/// <returns>The wrapped string. Same as the property Str.</returns>
public override string ToString()
{
return Str;
}
- /// <sumary>
+ /// <summary>
/// Override of GetHashCode for consistency with user-defined equality methods.
- /// </sumary>
+ /// </summary>
/// <returns>
/// The wrapped string hash code.
/// </returns>
return Str.GetHashCode();
}
- /// <sumary>
+ /// <summary>
/// Check the given object for equality.
- /// </sumary>
+ /// </summary>
/// <returns>
/// True if the given object is the same object or if it is another Stringshare object
/// and both wrapped strings are equal or if it is a string object and its content
return other.GetType() == typeof(Stringshare) && this == ((Stringshare)other);
}
- /// <sumary>
+ /// <summary>
/// Check the given Stringshare for equality.
- /// </sumary>
+ /// </summary>
/// <returns>
/// True if the given Stringshare object is not null and its wrapped string
/// have the same content of this.Str, false otherwise.
return this == other;
}
- /// <sumary>
+ /// <summary>
/// Check the given Stringshare for equality.
- /// </sumary>
+ /// </summary>
/// <returns>
/// True if the given string is not null and the wrapped string have the same
/// content of the given string, false otherwise.
return this.Str == other;
}
- /// <sumary>
+ /// <summary>
/// Get the wrapped string.
- /// <seealso cref="Stringshare.Str"/>
- /// <seealso cref="Stringshare.ToString()"/>
- /// </sumary>
+ /// <seealso cref="Str"/>
+ /// <seealso cref="ToString()"/>
+ /// </summary>
/// <returns>The wrapped string. Same as the property Str.</returns>
public string Get()
{
namespace Eo
{
+/// <summary>
+/// Abstract class that delivers base level binding to Efl Objects.
+///
+/// Most of it is protected functionalities to serve the generated
+/// binding classes that inherit from it.
+/// </summary>
public abstract class EoWrapper : IWrapper, IDisposable
{
+ /// <summary>Object used to synchronize access to EFL events.</summary>
protected readonly object eflBindingEventLock = new object();
private bool generated = true;
private System.IntPtr handle = IntPtr.Zero;
/// <summary>Initializes a new instance of the <see cref="Object"/> class.
/// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.
/// Do not implement this constructor.</summary>
- /// <param name="raw">The native pointer to be wrapped.</param>
+ /// <param name="wh">The native pointer to be wrapped.</param>
protected EoWrapper(Efl.Eo.Globals.WrappingHandle wh)
{
handle = wh.NativeHandle;
get;
}
+ /// <summary>
+ /// Whether this object type is one of the generated binding classes or a custom
+ /// class defined by the user and that inherit from one of the generated ones.
+ /// </summary>
+ /// <returns>
+ /// True if this object type is one of the generated binding classes,
+ /// false if it is class that is manually defined and that inherits from
+ /// one of the generated ones, including user defined classes.
+ /// </returns>
protected bool IsGeneratedBindingClass
{
get { return generated; }
ws.MakeShared();
}
- /// <sumary>Create and set to the internal native state a C# supervisor for this Eo wrapper. For internal use only.</sumary>
+ /// <summary>Create and set to the internal native state a C# supervisor for this Eo wrapper. For internal use only.</summary>
private void AddWrapperSupervisor()
{
var ws = new Efl.Eo.WrapperSupervisor(this);
Eina.Error.RaiseIfUnhandledException();
}
+ /// <summary>
+ /// Struct to be used when constructing objects from native code.
+ /// Wraps the pointer handle to the native object instance.
+ /// </summary>
protected struct ConstructingHandle
{
+ /// <summary>Constructor for wrapping the native handle.</summary>
public ConstructingHandle(IntPtr h)
{
NativeHandle = h;
}
+ /// <summary>Pointer to the native instance.</summary>
public IntPtr NativeHandle { get; private set; }
}
+ /// <summary>Wrapper for native methods and virtual method delegates.
+ /// For internal use by generated code only.</summary>
public abstract class NativeMethods : Efl.Eo.NativeClass
{
private static EflConstructorDelegate csharpEflConstructorStaticDelegate = new EflConstructorDelegate(Constructor);
private delegate IntPtr EflConstructorDelegate(IntPtr obj, IntPtr pd);
+ /// <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(Type type)
{
var descs = new System.Collections.Generic.List<Efl_Op_Description>();
projects / platform / upstream / efl.git / commitdiff