2002-05-23 23:43:25 +00:00
|
|
|
// GtkSharp.Generation.Parameters.cs - The Parameters Generation Class.
|
|
|
|
//
|
|
|
|
// Author: Mike Kestner <mkestner@speakeasy.net>
|
|
|
|
//
|
2004-06-25 16:35:15 +00:00
|
|
|
// Copyright (c) 2001-2003 Mike Kestner
|
|
|
|
// Copyright (c) 2004 Novell, Inc.
|
|
|
|
//
|
|
|
|
// This program is free software; you can redistribute it and/or
|
|
|
|
// modify it under the terms of version 2 of the GNU General Public
|
|
|
|
// License as published by the Free Software Foundation.
|
|
|
|
//
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
// General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public
|
|
|
|
// License along with this program; if not, write to the
|
|
|
|
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
// Boston, MA 02111-1307, USA.
|
|
|
|
|
2002-05-23 23:43:25 +00:00
|
|
|
|
|
|
|
namespace GtkSharp.Generation {
|
|
|
|
|
|
|
|
using System;
|
2003-09-11 06:10:03 +00:00
|
|
|
using System.Collections;
|
2002-06-10 12:34:09 +00:00
|
|
|
using System.IO;
|
2002-05-23 23:43:25 +00:00
|
|
|
using System.Xml;
|
|
|
|
|
2002-07-16 23:14:35 +00:00
|
|
|
public class Parameter {
|
|
|
|
|
|
|
|
private XmlElement elem;
|
|
|
|
|
|
|
|
public Parameter (XmlElement e)
|
|
|
|
{
|
|
|
|
elem = e;
|
|
|
|
}
|
|
|
|
|
2007-07-10 15:25:14 +00:00
|
|
|
string call_name;
|
|
|
|
public string CallName {
|
|
|
|
get {
|
|
|
|
if (call_name == null)
|
|
|
|
return Name;
|
|
|
|
else
|
|
|
|
return call_name;
|
|
|
|
}
|
|
|
|
set {
|
|
|
|
call_name = value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-08-28 20:58:01 +00:00
|
|
|
public string CType {
|
|
|
|
get {
|
2002-10-11 00:27:46 +00:00
|
|
|
string type = elem.GetAttribute("type");
|
|
|
|
if (type == "void*")
|
|
|
|
type = "gpointer";
|
|
|
|
return type;
|
2002-08-28 20:58:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-16 23:14:35 +00:00
|
|
|
public string CSType {
|
|
|
|
get {
|
2003-05-19 02:45:17 +00:00
|
|
|
string cstype = SymbolTable.Table.GetCSType( elem.GetAttribute("type"));
|
2002-10-11 00:27:46 +00:00
|
|
|
if (cstype == "void")
|
|
|
|
cstype = "System.IntPtr";
|
2003-09-12 06:38:29 +00:00
|
|
|
if (IsArray) {
|
2003-12-03 23:08:14 +00:00
|
|
|
if (IsParams)
|
|
|
|
cstype = "params " + cstype;
|
2002-08-28 20:58:01 +00:00
|
|
|
cstype += "[]";
|
2003-02-24 03:13:08 +00:00
|
|
|
cstype = cstype.Replace ("ref ", "");
|
|
|
|
}
|
2002-08-28 20:58:01 +00:00
|
|
|
return cstype;
|
2002-07-16 23:14:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-06-14 17:30:32 +00:00
|
|
|
public IGeneratable Generatable {
|
|
|
|
get {
|
|
|
|
return SymbolTable.Table[CType];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-09-12 06:38:29 +00:00
|
|
|
public bool IsArray {
|
|
|
|
get {
|
|
|
|
return elem.HasAttribute("array");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-09-11 06:10:03 +00:00
|
|
|
public bool IsEllipsis {
|
|
|
|
get {
|
|
|
|
return elem.HasAttribute("ellipsis");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-17 03:44:32 +00:00
|
|
|
public bool IsCount {
|
|
|
|
get {
|
|
|
|
|
|
|
|
if (Name.StartsWith("n_"))
|
|
|
|
switch (CSType) {
|
|
|
|
case "int":
|
|
|
|
case "uint":
|
|
|
|
case "long":
|
|
|
|
case "ulong":
|
|
|
|
case "short":
|
|
|
|
case "ushort":
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-05-04 11:47:25 +00:00
|
|
|
public bool IsDestroyNotify {
|
|
|
|
get {
|
|
|
|
return CType == "GDestroyNotify";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-02-24 03:13:08 +00:00
|
|
|
public bool IsLength {
|
|
|
|
get {
|
2003-09-11 05:11:18 +00:00
|
|
|
|
|
|
|
if (Name.EndsWith("len") || Name.EndsWith("length"))
|
|
|
|
switch (CSType) {
|
|
|
|
case "int":
|
|
|
|
case "uint":
|
|
|
|
case "long":
|
|
|
|
case "ulong":
|
|
|
|
case "short":
|
|
|
|
case "ushort":
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
2003-02-24 03:13:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-12-03 23:08:14 +00:00
|
|
|
public bool IsParams {
|
|
|
|
get {
|
|
|
|
return elem.HasAttribute("params");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-02-24 03:13:08 +00:00
|
|
|
public bool IsString {
|
|
|
|
get {
|
|
|
|
return (CSType == "string");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-09-12 06:38:29 +00:00
|
|
|
public bool IsUserData {
|
|
|
|
get {
|
2003-12-03 23:08:14 +00:00
|
|
|
return CSType == "IntPtr" && (Name.EndsWith ("data") || Name.EndsWith ("data_or_owner"));
|
2003-09-12 06:38:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
public virtual string MarshalType {
|
2002-08-04 04:23:13 +00:00
|
|
|
get {
|
2003-05-19 02:45:17 +00:00
|
|
|
string type = SymbolTable.Table.GetMarshalType( elem.GetAttribute("type"));
|
2007-08-13 14:29:06 +00:00
|
|
|
if (type == "void" || Generatable is IManualMarshaler)
|
|
|
|
type = "IntPtr";
|
2003-09-12 06:38:29 +00:00
|
|
|
if (IsArray) {
|
2003-02-24 03:13:08 +00:00
|
|
|
type += "[]";
|
|
|
|
type = type.Replace ("ref ", "");
|
|
|
|
}
|
2002-10-11 00:27:46 +00:00
|
|
|
return type;
|
2002-08-04 04:23:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-16 23:14:35 +00:00
|
|
|
public string Name {
|
|
|
|
get {
|
2003-08-28 16:49:29 +00:00
|
|
|
return SymbolTable.Table.MangleName (elem.GetAttribute("name"));
|
2002-07-16 23:14:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Automatic memory management for opaque types [#49565]
* glib/Opaque.cs (Owned): new property saying whether or not gtk#
owns the memory.
(Opaque): Set Owned to true in the void ctor and false in the
IntPtr one.
(GetOpaque): add a new overload that can also create opaques, a la
GLib.Object.GetObject.
(Ref, Unref, Free): empty virtual methods to be overridden by
subclasses.
(set_Raw): Unref() and possibly Free() the old value, Ref() the
new one.
(~Opaque, Dispose): set Raw to IntPtr.Zero (triggering Free/Unref
if needed)
* parser/gapi2xml.pl (addReturnElem): if the method is named Copy
and returns a pointer, set the "owned" attribute on the
return-type.
* */*-api.raw: Regen
* generator/HandleBase.cs (FromNative): Add new
FromNative/FromNativeReturn overloads that takes a "bool owned"
param. Implement the 1-arg FromNative and FromNativeReturn in
terms of that.
* generator/ObjectBase.cs (FromNative): Implement HandleBase's new
overload. Use the two-arg version of GLib.Object.GetObject when
"owned" is true.
* generator/OpaqueGen.cs (Generate): Pull out Ref, Unref, and
Free/Destroy/Dispose methods and handle them specially by
overriding Opaque.Ref, .Unref, and .Free appropriately. (If any
of the methods are marked deprecated, output a deprecated
do-nothing method as well, to save us from having to write all
those deprecated methods by hand.)
(FromNative): use GetOpaque, passing "owned".
* generator/ReturnValue.cs (FromNative): if the value is a
HandleBase, pass Owned to its FromNative().
* generator/Parameters.cs (Owned): new property (for use on out
params)
(FromNative): Call FromNative() on the generatable, handling Owned
in the case of HandleBase.
* generator/ManagedCallString.cs:
* generator/MethodBody.cs:
* generator/Signal.cs: use param.FromNative() rather than
param.Generatable.FromNative(), to get ownership right.
* */*.metadata: Mark opaque ref/unref/free methods deprecated
(except where we were hiding them before). Add "owned" attributes
to return values and out params as needed.
* pango/AttrIterator.custom (GetFont): work around a
memory-management oddity of the underlying method.
* pango/AttrFontDesc.cs (AttrFontDesc): copy the passed-in
FontDescriptor, since the attribute will assume ownership of it.
* gtk/TreeView.custom (GetPathAtPos): set the "owned" flag on the
returned TreePaths.
* gtk/TargetList.custom: Remove refcounting stuff, which is
now handled automatically
* gtk/NodeStore.cs (GetPath): clear the Owned flag on the created
TreePath so that the underlying structure doesn't get freed when
the function returns
* gtkhtml/HTMLStream.custom (Destroy): hide this and then
reimplement it by hand to keep OpaqueGen from using it in
Dispose(), since calling it after an HTMLStream.Close() will
result in a crash.
svn path=/trunk/gtk-sharp/; revision=47928
2005-08-02 18:45:21 +00:00
|
|
|
public bool Owned {
|
|
|
|
get {
|
|
|
|
return elem.GetAttribute ("owned") == "true";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-10 15:25:14 +00:00
|
|
|
public virtual string NativeSignature {
|
|
|
|
get {
|
2007-08-01 17:30:47 +00:00
|
|
|
string sig = MarshalType + " " + Name;
|
|
|
|
if (PassAs != String.Empty)
|
|
|
|
sig = PassAs + " " + sig;
|
|
|
|
return sig;
|
2007-07-10 15:25:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-07 13:42:59 +00:00
|
|
|
public string PropertyName {
|
|
|
|
get {
|
|
|
|
return elem.GetAttribute("property_name");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-10 15:25:14 +00:00
|
|
|
string pass_as;
|
|
|
|
|
2003-06-14 17:30:32 +00:00
|
|
|
public string PassAs {
|
|
|
|
get {
|
2007-07-10 15:25:14 +00:00
|
|
|
if (pass_as != null)
|
|
|
|
return pass_as;
|
|
|
|
|
2003-10-13 21:53:40 +00:00
|
|
|
if (elem.HasAttribute ("pass_as"))
|
|
|
|
return elem.GetAttribute ("pass_as");
|
|
|
|
|
2004-12-27 20:00:55 +00:00
|
|
|
if (IsArray || CSType.EndsWith ("IntPtr"))
|
2003-10-13 21:53:40 +00:00
|
|
|
return "";
|
|
|
|
|
2004-12-27 20:00:55 +00:00
|
|
|
if (CType.EndsWith ("*") && (Generatable is SimpleGen || Generatable is EnumGen))
|
2003-10-17 23:06:37 +00:00
|
|
|
return "out";
|
|
|
|
|
2003-10-13 21:53:40 +00:00
|
|
|
return "";
|
2003-06-14 17:30:32 +00:00
|
|
|
}
|
2007-07-10 15:25:14 +00:00
|
|
|
set {
|
|
|
|
pass_as = value;
|
|
|
|
}
|
2003-06-14 17:30:32 +00:00
|
|
|
}
|
|
|
|
|
2005-05-04 11:47:25 +00:00
|
|
|
string scope;
|
2005-04-04 16:27:08 +00:00
|
|
|
public string Scope {
|
|
|
|
get {
|
2005-05-04 11:47:25 +00:00
|
|
|
if (scope == null)
|
|
|
|
scope = elem.GetAttribute ("scope");
|
|
|
|
return scope;
|
|
|
|
}
|
|
|
|
set {
|
|
|
|
scope = value;
|
2005-04-04 16:27:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-30 19:40:49 +00:00
|
|
|
public virtual string[] Prepare {
|
2007-07-10 15:25:14 +00:00
|
|
|
get {
|
|
|
|
IGeneratable gen = Generatable;
|
2007-07-30 19:40:49 +00:00
|
|
|
if (gen is IManualMarshaler) {
|
2007-08-13 14:29:06 +00:00
|
|
|
string result = "IntPtr native_" + CallName;
|
2007-07-30 19:40:49 +00:00
|
|
|
if (PassAs != "out")
|
|
|
|
result += " = " + (gen as IManualMarshaler).AllocNative (CallName);
|
|
|
|
return new string [] { result + ";" };
|
2007-08-13 17:48:24 +00:00
|
|
|
} else if (PassAs == "out" && CSType != MarshalType)
|
2007-07-30 19:40:49 +00:00
|
|
|
return new string [] { gen.MarshalType + " native_" + CallName + ";" };
|
2007-07-10 15:25:14 +00:00
|
|
|
|
|
|
|
return new string [0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public virtual string CallString {
|
|
|
|
get {
|
|
|
|
string call_parm;
|
|
|
|
|
|
|
|
IGeneratable gen = Generatable;
|
|
|
|
if (gen is CallbackGen)
|
2007-07-30 19:40:49 +00:00
|
|
|
return SymbolTable.Table.CallByName (CType, CallName + "_wrapper");
|
2007-07-10 15:25:14 +00:00
|
|
|
else if (PassAs != String.Empty) {
|
2007-07-30 19:40:49 +00:00
|
|
|
call_parm = PassAs + " ";
|
2007-08-13 17:48:24 +00:00
|
|
|
if (CSType != MarshalType)
|
2007-07-30 19:40:49 +00:00
|
|
|
call_parm += "native_";
|
|
|
|
call_parm += CallName;
|
2007-07-10 15:25:14 +00:00
|
|
|
} else if (gen is IManualMarshaler)
|
2007-07-30 19:40:49 +00:00
|
|
|
call_parm = "native_" + CallName;
|
2007-07-10 15:25:14 +00:00
|
|
|
else
|
|
|
|
call_parm = SymbolTable.Table.CallByName(CType, CallName);
|
2003-12-03 23:08:14 +00:00
|
|
|
|
2007-07-10 15:25:14 +00:00
|
|
|
return call_parm;
|
|
|
|
}
|
Automatic memory management for opaque types [#49565]
* glib/Opaque.cs (Owned): new property saying whether or not gtk#
owns the memory.
(Opaque): Set Owned to true in the void ctor and false in the
IntPtr one.
(GetOpaque): add a new overload that can also create opaques, a la
GLib.Object.GetObject.
(Ref, Unref, Free): empty virtual methods to be overridden by
subclasses.
(set_Raw): Unref() and possibly Free() the old value, Ref() the
new one.
(~Opaque, Dispose): set Raw to IntPtr.Zero (triggering Free/Unref
if needed)
* parser/gapi2xml.pl (addReturnElem): if the method is named Copy
and returns a pointer, set the "owned" attribute on the
return-type.
* */*-api.raw: Regen
* generator/HandleBase.cs (FromNative): Add new
FromNative/FromNativeReturn overloads that takes a "bool owned"
param. Implement the 1-arg FromNative and FromNativeReturn in
terms of that.
* generator/ObjectBase.cs (FromNative): Implement HandleBase's new
overload. Use the two-arg version of GLib.Object.GetObject when
"owned" is true.
* generator/OpaqueGen.cs (Generate): Pull out Ref, Unref, and
Free/Destroy/Dispose methods and handle them specially by
overriding Opaque.Ref, .Unref, and .Free appropriately. (If any
of the methods are marked deprecated, output a deprecated
do-nothing method as well, to save us from having to write all
those deprecated methods by hand.)
(FromNative): use GetOpaque, passing "owned".
* generator/ReturnValue.cs (FromNative): if the value is a
HandleBase, pass Owned to its FromNative().
* generator/Parameters.cs (Owned): new property (for use on out
params)
(FromNative): Call FromNative() on the generatable, handling Owned
in the case of HandleBase.
* generator/ManagedCallString.cs:
* generator/MethodBody.cs:
* generator/Signal.cs: use param.FromNative() rather than
param.Generatable.FromNative(), to get ownership right.
* */*.metadata: Mark opaque ref/unref/free methods deprecated
(except where we were hiding them before). Add "owned" attributes
to return values and out params as needed.
* pango/AttrIterator.custom (GetFont): work around a
memory-management oddity of the underlying method.
* pango/AttrFontDesc.cs (AttrFontDesc): copy the passed-in
FontDescriptor, since the attribute will assume ownership of it.
* gtk/TreeView.custom (GetPathAtPos): set the "owned" flag on the
returned TreePaths.
* gtk/TargetList.custom: Remove refcounting stuff, which is
now handled automatically
* gtk/NodeStore.cs (GetPath): clear the Owned flag on the created
TreePath so that the underlying structure doesn't get freed when
the function returns
* gtkhtml/HTMLStream.custom (Destroy): hide this and then
reimplement it by hand to keep OpaqueGen from using it in
Dispose(), since calling it after an HTMLStream.Close() will
result in a crash.
svn path=/trunk/gtk-sharp/; revision=47928
2005-08-02 18:45:21 +00:00
|
|
|
}
|
2003-12-03 23:08:14 +00:00
|
|
|
|
2007-07-30 19:40:49 +00:00
|
|
|
public virtual string[] Finish {
|
|
|
|
get {
|
|
|
|
IGeneratable gen = Generatable;
|
|
|
|
if (gen is IManualMarshaler) {
|
|
|
|
string[] result = new string [PassAs == "ref" ? 2 : 1];
|
|
|
|
int i = 0;
|
|
|
|
if (PassAs != String.Empty)
|
|
|
|
result [i++] = CallName + " = " + Generatable.FromNative ("native_" + CallName) + ";";
|
|
|
|
if (PassAs != "out")
|
|
|
|
result [i] = (gen as IManualMarshaler).ReleaseNative ("native_" + CallName) + ";";
|
|
|
|
return result;
|
2007-08-13 17:48:24 +00:00
|
|
|
} else if (PassAs != String.Empty && MarshalType != CSType)
|
2007-07-30 19:40:49 +00:00
|
|
|
return new string [] { CallName + " = " + gen.FromNative ("native_" + CallName) + ";" };
|
|
|
|
return new string [0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Automatic memory management for opaque types [#49565]
* glib/Opaque.cs (Owned): new property saying whether or not gtk#
owns the memory.
(Opaque): Set Owned to true in the void ctor and false in the
IntPtr one.
(GetOpaque): add a new overload that can also create opaques, a la
GLib.Object.GetObject.
(Ref, Unref, Free): empty virtual methods to be overridden by
subclasses.
(set_Raw): Unref() and possibly Free() the old value, Ref() the
new one.
(~Opaque, Dispose): set Raw to IntPtr.Zero (triggering Free/Unref
if needed)
* parser/gapi2xml.pl (addReturnElem): if the method is named Copy
and returns a pointer, set the "owned" attribute on the
return-type.
* */*-api.raw: Regen
* generator/HandleBase.cs (FromNative): Add new
FromNative/FromNativeReturn overloads that takes a "bool owned"
param. Implement the 1-arg FromNative and FromNativeReturn in
terms of that.
* generator/ObjectBase.cs (FromNative): Implement HandleBase's new
overload. Use the two-arg version of GLib.Object.GetObject when
"owned" is true.
* generator/OpaqueGen.cs (Generate): Pull out Ref, Unref, and
Free/Destroy/Dispose methods and handle them specially by
overriding Opaque.Ref, .Unref, and .Free appropriately. (If any
of the methods are marked deprecated, output a deprecated
do-nothing method as well, to save us from having to write all
those deprecated methods by hand.)
(FromNative): use GetOpaque, passing "owned".
* generator/ReturnValue.cs (FromNative): if the value is a
HandleBase, pass Owned to its FromNative().
* generator/Parameters.cs (Owned): new property (for use on out
params)
(FromNative): Call FromNative() on the generatable, handling Owned
in the case of HandleBase.
* generator/ManagedCallString.cs:
* generator/MethodBody.cs:
* generator/Signal.cs: use param.FromNative() rather than
param.Generatable.FromNative(), to get ownership right.
* */*.metadata: Mark opaque ref/unref/free methods deprecated
(except where we were hiding them before). Add "owned" attributes
to return values and out params as needed.
* pango/AttrIterator.custom (GetFont): work around a
memory-management oddity of the underlying method.
* pango/AttrFontDesc.cs (AttrFontDesc): copy the passed-in
FontDescriptor, since the attribute will assume ownership of it.
* gtk/TreeView.custom (GetPathAtPos): set the "owned" flag on the
returned TreePaths.
* gtk/TargetList.custom: Remove refcounting stuff, which is
now handled automatically
* gtk/NodeStore.cs (GetPath): clear the Owned flag on the created
TreePath so that the underlying structure doesn't get freed when
the function returns
* gtkhtml/HTMLStream.custom (Destroy): hide this and then
reimplement it by hand to keep OpaqueGen from using it in
Dispose(), since calling it after an HTMLStream.Close() will
result in a crash.
svn path=/trunk/gtk-sharp/; revision=47928
2005-08-02 18:45:21 +00:00
|
|
|
public string FromNative (string var)
|
|
|
|
{
|
|
|
|
if (Generatable is HandleBase)
|
|
|
|
return ((HandleBase)Generatable).FromNative (var, Owned);
|
|
|
|
else
|
|
|
|
return Generatable.FromNative (var);
|
2003-12-03 23:08:14 +00:00
|
|
|
}
|
|
|
|
|
2002-07-16 23:14:35 +00:00
|
|
|
public string StudlyName {
|
|
|
|
get {
|
|
|
|
string name = elem.GetAttribute("name");
|
|
|
|
string[] segs = name.Split('_');
|
|
|
|
string studly = "";
|
|
|
|
foreach (string s in segs) {
|
2003-07-15 05:52:09 +00:00
|
|
|
if (s.Trim () == "")
|
|
|
|
continue;
|
2002-07-16 23:14:35 +00:00
|
|
|
studly += (s.Substring(0,1).ToUpper() + s.Substring(1));
|
|
|
|
}
|
|
|
|
return studly;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-10 15:25:14 +00:00
|
|
|
public class ArrayParameter : Parameter {
|
|
|
|
|
|
|
|
public ArrayParameter (XmlElement elem) : base (elem) {}
|
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
public override string MarshalType {
|
|
|
|
get {
|
|
|
|
if (Generatable is StructBase)
|
|
|
|
return CSType;
|
|
|
|
else
|
|
|
|
return base.MarshalType;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-30 19:40:49 +00:00
|
|
|
public override string[] Prepare {
|
2007-07-10 15:25:14 +00:00
|
|
|
get {
|
|
|
|
if (CSType == MarshalType)
|
|
|
|
return new string [0];
|
|
|
|
|
2007-07-30 19:40:49 +00:00
|
|
|
ArrayList result = new ArrayList ();
|
|
|
|
result.Add (String.Format ("int cnt_{0} = {0} == null ? 0 : {0}.Length;", CallName));
|
|
|
|
result.Add (String.Format ("{0}[] native_{1} = new {0} [cnt_{1}];", MarshalType.TrimEnd('[', ']'), CallName));
|
|
|
|
result.Add (String.Format ("for (int i = 0; i < cnt_{0}; i++)", CallName));
|
2007-07-10 15:25:14 +00:00
|
|
|
IGeneratable gen = Generatable;
|
|
|
|
if (gen is IManualMarshaler)
|
2007-07-30 19:40:49 +00:00
|
|
|
result.Add (String.Format ("\tnative_{0} [i] = {1};", CallName, (gen as IManualMarshaler).AllocNative (CallName + "[i]")));
|
2007-07-10 15:25:14 +00:00
|
|
|
else
|
2007-07-30 19:40:49 +00:00
|
|
|
result.Add (String.Format ("\tnative_{0} [i] = {1};", CallName, gen.CallByName (CallName + "[i]")));
|
|
|
|
return (string[]) result.ToArray (typeof (string));
|
2007-07-10 15:25:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string CallString {
|
|
|
|
get {
|
|
|
|
if (CSType != MarshalType)
|
|
|
|
return "native_" + CallName;
|
|
|
|
else
|
|
|
|
return CallName;
|
|
|
|
}
|
|
|
|
}
|
2007-07-30 19:40:49 +00:00
|
|
|
|
|
|
|
public override string[] Finish {
|
|
|
|
get {
|
2007-08-13 14:29:06 +00:00
|
|
|
if (CSType == MarshalType)
|
|
|
|
return new string [0];
|
|
|
|
|
2007-07-30 19:40:49 +00:00
|
|
|
IGeneratable gen = Generatable;
|
|
|
|
if (gen is IManualMarshaler) {
|
|
|
|
string [] result = new string [4];
|
|
|
|
result [0] = "for (int i = 0; i < native_" + CallName + ".Length; i++) {";
|
|
|
|
result [1] = "\t" + CallName + " [i] = " + Generatable.FromNative ("native_" + CallName + "[i]") + ";";
|
|
|
|
result [2] = "\t" + (gen as IManualMarshaler).ReleaseNative ("native_" + CallName + "[i]") + ";";
|
|
|
|
result [3] = "}";
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
return new string [0];
|
|
|
|
}
|
|
|
|
}
|
2007-07-10 15:25:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public class ArrayCountPair : ArrayParameter {
|
|
|
|
|
|
|
|
XmlElement count_elem;
|
|
|
|
bool invert;
|
|
|
|
|
|
|
|
public ArrayCountPair (XmlElement array_elem, XmlElement count_elem, bool invert) : base (array_elem)
|
|
|
|
{
|
|
|
|
this.count_elem = count_elem;
|
|
|
|
this.invert = invert;
|
|
|
|
}
|
|
|
|
|
|
|
|
string CountType {
|
|
|
|
get {
|
|
|
|
return SymbolTable.Table.GetCSType(count_elem.GetAttribute("type"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string CountCast {
|
|
|
|
get {
|
|
|
|
if (CountType == "int")
|
|
|
|
return String.Empty;
|
|
|
|
else
|
|
|
|
return "(" + CountType + ") ";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string CountName {
|
|
|
|
get {
|
|
|
|
return SymbolTable.Table.MangleName (count_elem.GetAttribute("name"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string CallCount (string name)
|
|
|
|
{
|
|
|
|
string result = name + " == null ? 0 : ";
|
|
|
|
result += CountCast + name + ".Length";
|
|
|
|
IGeneratable gen = SymbolTable.Table[count_elem.GetAttribute("type")];
|
|
|
|
return gen.CallByName (result);
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string CallString {
|
|
|
|
get {
|
|
|
|
if (invert)
|
|
|
|
return CallCount (CallName) + ", " + base.CallString;
|
|
|
|
else
|
|
|
|
return base.CallString + ", " + CallCount (CallName);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string NativeSignature {
|
|
|
|
get {
|
|
|
|
if (invert)
|
|
|
|
return CountType + " " + CountName + ", " + MarshalType + " " + Name;
|
|
|
|
else
|
|
|
|
return MarshalType + " " + Name + ", " + CountType + " " + CountName;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public class ErrorParameter : Parameter {
|
|
|
|
|
|
|
|
public ErrorParameter (XmlElement elem) : base (elem)
|
|
|
|
{
|
|
|
|
PassAs = "out";
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string CallString {
|
|
|
|
get {
|
|
|
|
return "out error";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
public class StructParameter : Parameter {
|
|
|
|
|
|
|
|
public StructParameter (XmlElement elem) : base (elem) {}
|
|
|
|
|
|
|
|
public override string MarshalType {
|
|
|
|
get {
|
|
|
|
return "IntPtr";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string[] Prepare {
|
|
|
|
get {
|
|
|
|
if (PassAs == "out")
|
|
|
|
return new string [] { "IntPtr native_" + CallName + " = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (" + Generatable.QualifiedName + ")));"};
|
|
|
|
else
|
|
|
|
return new string [] { "IntPtr native_" + CallName + " = " + (Generatable as IManualMarshaler).AllocNative (CallName) + ";"};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string CallString {
|
|
|
|
get {
|
|
|
|
return "native_" + CallName;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string[] Finish {
|
|
|
|
get {
|
|
|
|
string[] result = new string [2];
|
|
|
|
result [0] = CallName + " = " + FromNative ("native_" + CallName) + ";";
|
|
|
|
result [1] = (Generatable as IManualMarshaler).ReleaseNative ("native_" + CallName) + ";";
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override string NativeSignature {
|
|
|
|
get {
|
|
|
|
return "IntPtr " + CallName;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-26 19:17:07 +00:00
|
|
|
public class Parameters : IEnumerable {
|
2002-05-23 23:43:25 +00:00
|
|
|
|
2005-01-26 19:17:07 +00:00
|
|
|
ArrayList param_list = new ArrayList ();
|
2007-08-13 14:29:06 +00:00
|
|
|
XmlElement elem;
|
2002-05-23 23:43:25 +00:00
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
public Parameters (XmlElement elem)
|
|
|
|
{
|
2005-01-26 19:17:07 +00:00
|
|
|
if (elem == null)
|
2007-08-13 14:29:06 +00:00
|
|
|
valid = true;
|
|
|
|
this.elem = elem;
|
2002-05-23 23:43:25 +00:00
|
|
|
}
|
|
|
|
|
2003-09-11 06:10:03 +00:00
|
|
|
public int Count {
|
|
|
|
get {
|
|
|
|
return param_list.Count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
public int VisibleCount {
|
|
|
|
get {
|
|
|
|
int visible = 0;
|
|
|
|
foreach (Parameter p in this) {
|
|
|
|
if (!IsHidden (p))
|
|
|
|
visible++;
|
|
|
|
}
|
|
|
|
return visible;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-16 23:14:35 +00:00
|
|
|
public Parameter this [int idx] {
|
|
|
|
get {
|
2003-09-11 06:10:03 +00:00
|
|
|
return param_list [idx] as Parameter;
|
2002-07-16 23:14:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
public bool IsHidden (Parameter p)
|
|
|
|
{
|
|
|
|
int idx = param_list.IndexOf (p);
|
|
|
|
|
|
|
|
if (idx > 0 && p.IsLength && this [idx - 1].IsString)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (p.IsCount && ((idx > 0 && this [idx - 1].IsArray) ||
|
|
|
|
(idx < Count - 1 && this [idx + 1].IsArray)))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (p.CType == "GError**")
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (HasCB || HideData) {
|
|
|
|
if (p.IsUserData && (idx == Count - 1))
|
* parser/gapi2xml.pl (addParamsElem): change the handling of
anonymous function pointer types in method signatures. Before, we
added a <callback> child to the <parameters> node, but the
generator just ignored it. Now we add the callback (with a made-up
name) to the toplevel node, and add an ordinary <param> node
referencing it to the <parameters> node. Also, if the last param
of the callback is a gpointer, rename it from "arg#" to "data" so
it will be treated correctly (as the user data passed from the
calling method). [Fixes #66241]
* art/art-api.raw:
* gdk/gdk-api-2.4.raw:
* gdk/gdk-api-2.6.raw: Regen
* generator/Parameters.cs (IsHidden): loosen the definition of
hideable user_data; it doesn't have to occur at the end of the
parameter list, as long as there's a callback arg before it.
* generator/MethodBody.cs (GetCallString): Use Parameters.IsHidden
to decide whether or not to squash user_data params, rather than
trying to duplicate its logic. As a side effect, this also causes
a handful of methods that take non-hidden IntPtr arguments to
start actually passing those arguments to C rather than always
passing IntPtr.Zero.
* generator/Method.cs (Equals, GetHashCode): Remove unnecessary
and possibly erroneous hashing overrides.
* gtk/Gtk.metadata: Hide Gtk.Container.ForeachFull, since it's
useless and wasn't in gtk# 1.0
* gtk/Menu.custom (Popup):
* gtk/TextIter.custom (ForwardFindChar, BackwardFindChar):
* gnome/App.custom (CreateMenusInterp, InsertMenusInterp,
CreateToolbarInterp):
* gnome/Client.custom (RequestInteractionInterp):
* gnome/Popup.custom (MenuDoPopupModal, MenuDoPopup): Add
[Obsolete] compat overloads for methods that have now lost a
useless IntPtr.
svn path=/trunk/gtk-sharp/; revision=47566
2005-07-22 19:10:04 +00:00
|
|
|
return true;
|
|
|
|
if (p.IsUserData && idx > 0 &&
|
|
|
|
this [idx - 1].Generatable is CallbackGen)
|
2005-05-04 11:47:25 +00:00
|
|
|
return true;
|
|
|
|
if (p.IsDestroyNotify && (idx == Count - 1) &&
|
|
|
|
this [idx - 1].IsUserData)
|
|
|
|
return true;
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool has_cb;
|
|
|
|
public bool HasCB {
|
|
|
|
get { return has_cb; }
|
|
|
|
set { has_cb = value; }
|
|
|
|
}
|
|
|
|
|
2005-01-26 19:17:07 +00:00
|
|
|
bool hide_data;
|
2002-08-28 20:58:01 +00:00
|
|
|
public bool HideData {
|
|
|
|
get { return hide_data; }
|
|
|
|
set { hide_data = value; }
|
|
|
|
}
|
|
|
|
|
2005-01-26 19:17:07 +00:00
|
|
|
bool is_static;
|
2003-04-06 09:21:15 +00:00
|
|
|
public bool Static {
|
2003-12-03 23:08:14 +00:00
|
|
|
get { return is_static; }
|
2003-04-06 09:21:15 +00:00
|
|
|
set { is_static = value; }
|
|
|
|
}
|
|
|
|
|
2005-01-26 19:17:07 +00:00
|
|
|
void Clear ()
|
|
|
|
{
|
2007-08-13 14:29:06 +00:00
|
|
|
elem = null;
|
2005-01-26 19:17:07 +00:00
|
|
|
param_list.Clear ();
|
2007-08-13 14:29:06 +00:00
|
|
|
param_list = null;
|
2005-01-26 19:17:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
|
|
{
|
|
|
|
return param_list.GetEnumerator ();
|
|
|
|
}
|
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
bool valid = false;
|
|
|
|
|
2002-05-23 23:43:25 +00:00
|
|
|
public bool Validate ()
|
|
|
|
{
|
2007-08-13 14:29:06 +00:00
|
|
|
if (valid)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (elem == null)
|
2005-01-26 19:17:07 +00:00
|
|
|
return false;
|
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
for (int i = 0; i < elem.ChildNodes.Count; i++) {
|
|
|
|
XmlElement parm = elem.ChildNodes [i] as XmlElement;
|
|
|
|
if (parm == null || parm.Name != "parameter")
|
|
|
|
continue;
|
|
|
|
Parameter p = new Parameter (parm);
|
2003-09-11 06:10:03 +00:00
|
|
|
|
|
|
|
if (p.IsEllipsis) {
|
2002-07-20 14:43:48 +00:00
|
|
|
Console.Write("Ellipsis parameter ");
|
2005-01-26 19:17:07 +00:00
|
|
|
Clear ();
|
2002-07-20 14:43:48 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2003-02-24 03:13:08 +00:00
|
|
|
if ((p.CSType == "") || (p.Name == "") ||
|
2003-05-19 02:45:17 +00:00
|
|
|
(p.MarshalType == "") || (SymbolTable.Table.CallByName(p.CType, p.Name) == "")) {
|
2003-02-24 03:13:08 +00:00
|
|
|
Console.Write("Name: " + p.Name + " Type: " + p.CType + " ");
|
2005-01-26 19:17:07 +00:00
|
|
|
Clear ();
|
2002-05-23 23:43:25 +00:00
|
|
|
return false;
|
|
|
|
}
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
IGeneratable gen = p.Generatable;
|
|
|
|
|
|
|
|
if (p.IsArray) {
|
|
|
|
p = new ArrayParameter (parm);
|
|
|
|
if (i < elem.ChildNodes.Count - 1) {
|
|
|
|
XmlElement next = elem.ChildNodes [i + 1] as XmlElement;
|
|
|
|
if (next != null || next.Name == "parameter") {
|
|
|
|
Parameter c = new Parameter (next);
|
|
|
|
if (c.IsCount) {
|
|
|
|
p = new ArrayCountPair (parm, next, false);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (p.IsCount && i < elem.ChildNodes.Count - 1) {
|
|
|
|
XmlElement next = elem.ChildNodes [i + 1] as XmlElement;
|
|
|
|
if (next != null || next.Name == "parameter") {
|
|
|
|
Parameter a = new Parameter (next);
|
|
|
|
if (a.IsArray) {
|
|
|
|
p = new ArrayCountPair (next, parm, true);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (p.CType == "GError**")
|
|
|
|
p = new ErrorParameter (parm);
|
2007-08-13 17:48:24 +00:00
|
|
|
else if (gen is StructBase || gen is ByRefGen) {
|
2007-08-13 14:29:06 +00:00
|
|
|
p = new StructParameter (parm);
|
|
|
|
} else if (gen is CallbackGen) {
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
has_cb = true;
|
2005-05-04 11:47:25 +00:00
|
|
|
}
|
2007-08-13 14:29:06 +00:00
|
|
|
param_list.Add (p);
|
2002-06-21 Rachel Hestilow <hestilow@ximian.com>
* generator/ClassBase.cs: New base class for classes and interfaces.
* generator/InterfaceGen.cs: Inherit from ClassBase, generate declarations.
* generator/ObjectGen.cs: Move half of this into ClassBase.
* generator/Method.cs: Turn all applicable Get/Set functions into .NET
accessors. Remove redundant == overload and move into Equals, as
it was confusing "!= null".
* generator/Parameters.cs: Alter signature creation to accept "is_set"
option, add support for variable arguments. Add properties "Count",
"IsVarArgs", "VAType".
* generator/Ctor.cs: Fixup for changes in Parameters (indenting,
signature creation).
* generator/Signal.cs: Support generating declarations.
* generator/SymbolTable: Change GetObjectGen to GetClassGen.
* glib/IWrapper.cs: Move "Handle" declaration to here, so
both classes and interfaces can benefit from it.
* glib/Object.cs: Inherit from IWrapper.cs
* parser/Metadata.pm: Support attribute changes on constructors,
methods, signals, and paramater lists.
* parser/gapi2xml.pl: Parse init funcs for interfaces. Ignore "_"
functions here.
* parser/gapi_pp.pl: Remove boxed_type_register check, as it will
be caught in the init funcs.
* parser/Atk.metadata: Added.
* parser/Gtk.metadata: Add all needed signal/method collision
renames. Rename GtkEditable.Editable accessors to IsEditable,
as .NET does not like accessors with the same name as their
declaring type. Tag TreeStore constructor as varargs.
* samples/ButtonApp.cs: s/EmitAdd/Add.
* samples/Menu.cs: s/EmitAdd/Add, s/Activate/Activated.
svn path=/trunk/gtk-sharp/; revision=5394
2002-06-21 17:15:19 +00:00
|
|
|
}
|
|
|
|
|
2007-08-13 14:29:06 +00:00
|
|
|
if (has_cb && Count > 2 && this [Count - 3].Generatable is CallbackGen && this [Count - 2].IsUserData && this [Count - 1].IsDestroyNotify)
|
|
|
|
this [Count - 3].Scope = "notified";
|
|
|
|
|
|
|
|
valid = true;
|
2002-06-21 Rachel Hestilow <hestilow@ximian.com>
* generator/ClassBase.cs: New base class for classes and interfaces.
* generator/InterfaceGen.cs: Inherit from ClassBase, generate declarations.
* generator/ObjectGen.cs: Move half of this into ClassBase.
* generator/Method.cs: Turn all applicable Get/Set functions into .NET
accessors. Remove redundant == overload and move into Equals, as
it was confusing "!= null".
* generator/Parameters.cs: Alter signature creation to accept "is_set"
option, add support for variable arguments. Add properties "Count",
"IsVarArgs", "VAType".
* generator/Ctor.cs: Fixup for changes in Parameters (indenting,
signature creation).
* generator/Signal.cs: Support generating declarations.
* generator/SymbolTable: Change GetObjectGen to GetClassGen.
* glib/IWrapper.cs: Move "Handle" declaration to here, so
both classes and interfaces can benefit from it.
* glib/Object.cs: Inherit from IWrapper.cs
* parser/Metadata.pm: Support attribute changes on constructors,
methods, signals, and paramater lists.
* parser/gapi2xml.pl: Parse init funcs for interfaces. Ignore "_"
functions here.
* parser/gapi_pp.pl: Remove boxed_type_register check, as it will
be caught in the init funcs.
* parser/Atk.metadata: Added.
* parser/Gtk.metadata: Add all needed signal/method collision
renames. Rename GtkEditable.Editable accessors to IsEditable,
as .NET does not like accessors with the same name as their
declaring type. Tag TreeStore constructor as varargs.
* samples/ButtonApp.cs: s/EmitAdd/Add.
* samples/Menu.cs: s/EmitAdd/Add, s/Activate/Activated.
svn path=/trunk/gtk-sharp/; revision=5394
2002-06-21 17:15:19 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2002-06-10 12:34:09 +00:00
|
|
|
public bool IsAccessor {
|
|
|
|
get {
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
return VisibleCount == 1 && AccessorParam.PassAs == "out";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public Parameter AccessorParam {
|
|
|
|
get {
|
|
|
|
foreach (Parameter p in this) {
|
|
|
|
if (!IsHidden (p))
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return null;
|
2002-06-10 12:34:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public string AccessorReturnType {
|
|
|
|
get {
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
Parameter p = AccessorParam;
|
|
|
|
if (p != null)
|
|
|
|
return p.CSType;
|
2003-09-11 06:10:03 +00:00
|
|
|
else
|
|
|
|
return null;
|
2002-06-10 12:34:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public string AccessorName {
|
|
|
|
get {
|
* generator/Parameters.cs (IsHidden): method to check if a
parameter should be hidden in the managed sig (eg, because it's
user_data, or it's the length of the preceding array/string, etc).
(VisibleCount): the number of parameters that will actually be
exposed in the managed signature.
(IsAccessor): test VisibleCount, not Count
(AccessorReturnType, AccessorName): deal with the fact that the
accessor parameter might not be the first one.
* generator/CallbackGen.cs:
* generator/Signature.cs: use Parameters.IsHidden.
* generator/Method.cs (Initialize): set is_set based on
VisibleCount, not Count.
(Validate): call base.Validate() before Initialize() so that
VisibleCount will be correct in Initialize.
* generator/MethodBody.cs (GetCallString, CallArrayLength,
Initialize): update to deal with accessors with multiple args.
* gtk/Clipboard.custom (SetText): implement as an Obsolete variant
of the Text property
* gtk/IconTheme.custom (SearchPath, SetSearchPath): obsolete
SetSearchPath, implement a setter on SearchPath instead.
* gtk/ListStore.custom (SetColumnTypes):
* gtk/TreeStore.custom (SetColumnTypes): implement as an Obsolete
variant of the ColumnTypes property.
* glade/XML.custom (CustomHandler): implement as a property
(SetCustomHandler): Mark this obsolete
* glade/Global.custom (SetCustomHandler): deprecate in favor of
XML.CustomHandler.
* gnomedb/Editor.custom (SetText): implement as an Obsolete
variant of the Text property
svn path=/trunk/gtk-sharp/; revision=43898
2005-05-02 20:10:03 +00:00
|
|
|
Parameter p = AccessorParam;
|
|
|
|
if (p != null)
|
|
|
|
return p.Name;
|
2003-09-11 06:10:03 +00:00
|
|
|
else
|
|
|
|
return null;
|
2002-06-10 12:34:09 +00:00
|
|
|
}
|
|
|
|
}
|
2007-08-01 17:30:47 +00:00
|
|
|
|
|
|
|
public string ImportSignature {
|
|
|
|
get {
|
|
|
|
if (Count == 0)
|
|
|
|
return String.Empty;
|
|
|
|
|
|
|
|
string[] result = new string [Count];
|
|
|
|
for (int i = 0; i < Count; i++)
|
|
|
|
result [i] = this [i].NativeSignature;
|
|
|
|
|
|
|
|
return String.Join (", ", result);
|
|
|
|
}
|
|
|
|
}
|
2002-05-23 23:43:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|