X-Git-Url: https://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/8fcffcc668f4782447beb64a823cc15961cea9ab..489e97ede850a8de01ca3bd653dce9c25dcd54a1:/src/test.gob

diff --git a/src/test.gob b/src/test.gob
index e31319b..9dca3c8 100644
--- a/src/test.gob
+++ b/src/test.gob
@@ -3,10 +3,15 @@
    look in here to see a whole array of different syntax options, but
    don't expect this to be an easy to read file */
 
-requires 0.93.0
+requires 1.99.0
+
+%at{
+/* ALL TOP */
+%}
 
 %headertop{
 /* this should go on the very top of the header */
+
 %}
 %ht{
 /* this should go on the very top of the header as well */
@@ -21,12 +26,13 @@ requires 0.93.0
 
 %{
 #include <stdio.h>
+#include <gtk/gtk.h>
 /* the next line is not mandatory, but if gob finds an include in one of
    the %{ %} sections above the class definitions, it will not put it in
    the file itself.  So you can this way select where the include file is
    at */
-#include "gtk-weird-button.h"
-#include "gtk-weird-button-private.h"
+#include "test-object.h"
+#include "test-object-private.h"
 
 /* this is to test if the lexer won't get confused by requires inside
    some c code
@@ -34,9 +40,21 @@ requires 99.99.99
 */
 
 static void jjjj(void);
+
+#define _(x) x
 %}
 
 %h{
+enum _gob__enum_t {
+	BUDLIKY, BUDLIKY2
+};
+
+struct _gob__struct_t {
+	int i, x, y, z;
+};
+union _gob__union_t {
+	int i, x, y, z;
+};
 void bubu(void);
 %}
 %header{
@@ -44,7 +62,40 @@ void bubu(void);
 #define TEST_ARRAY 5
 %}
 
-class Gtk:Weird:Button from Gtk:Button {
+enum LAME_CLIENT {
+	IS_CONNECTED,
+	NONE = 9,
+	LAST
+} Test:Enum;
+
+flags BUGA_BUGA {
+	ONE,
+	TWO,
+	MANY,
+} Some:Flags;
+
+error TEST_OBJECT_ERROR {
+	BAD_THIS,
+	BAD_THAT
+} Test:Object:Error;
+
+class Test:Object from G:Object
+	(interface Gtk:Tree:Model)
+	/* We can add more interfaces by adding more lines like the above */
+	/* Note that there must exist a GtkTreeModelIface structure */
+{
+
+	/* function implemented for the Gtk:Tree:Model interface */
+	interface Gtk:Tree:Model
+	private GtkTreeModelFlags
+	get_flags (Gtk:Tree:Model *self (check null type))
+	{
+		/* FOO */
+		return (GtkTreeModelFlags)0;
+	}
+
+
+
 	public int test_array[TEST_ARRAY];
 	public int i;
 	argument INT i set { self->i = ARG; } get { ARG = self->i; } ;
@@ -56,21 +107,21 @@ class Gtk:Weird:Button from Gtk:Button {
 		destroywith g_free;
 	argument POINTER testingstring stringlink;
 
-	public Gtk:Weird:Button * testingobj
-		destroywith gtk_object_unref;
+	public Test:Object * testingobj
+		destroywith g_object_unref;
 	argument POINTER testingobj objectlink;
 
 	classwide int foo = 20;
 	argument INT foo link;
 
-	public Gtk:Object * testingobj2
+	public G:Object * testingobj2
 		destroy {
 			if(VAR)
-				gtk_object_unref(GTK_OBJECT(VAR));
+				g_object_unref(G_OBJECT(VAR));
 		};
-	argument POINTER (type Gtk:Object *) testingobj2 objectlink;
+	argument POINTER (type G:Object *) testingobj2 objectlink;
 	
-	argument POINTER (type GtkObject *) some_object
+	argument POINTER (type GObject *) some_object
 		set { /* set some_object */ }
 		get { /* get some_object */
 			ARG=NULL; };
@@ -79,8 +130,70 @@ class Gtk:Weird:Button from Gtk:Button {
 	argument POINTER (type char *) read_only_string
 		get { /* get readonly_long */
 			ARG = g_strdup("BLAH"); };
+
+	private char a_property;
+	property CHAR a_property
+		(nick = _("Nick"),
+		 blurb = _("Blurb"),
+		 minimum = 'a',
+		 maximum = 'Z',
+		 default_value = 'C',
+		 export)
+		set { self->_priv->a_property = g_value_get_char (VAL); }
+		get { g_value_set_char (VAL, self->_priv->a_property); };
+
+	property OBJECT foobarblahllll1
+		(nick = "xxxxxxx1",
+		 blurb = "yyyyyy",
+		 object_type = Gtk:Button)
+		get { /* FOO1 */ };
+	property OBJECT foobarblahllll2
+		(nick = "xxxxxxx2",
+		 blurb = "yyyyyy",
+		 object_type = G:Object)
+		set { /* FOO2 */ };
+
+	private double dblnum;
+	property DOUBLE dblnum
+		(nick = _("dblnum"),
+		 blurb = _("dblnum"),
+		 minimum = 0.1,
+		 maximum = 99.1,
+		 default_value = 0.3,
+		 flags = CONSTRUCT|CONSTRUCT_ONLY,
+		 export,
+		 link);
+
+	private char *b_property;
+	property STRING b_property
+		(nick = _("Nick b"),
+		 blurb = _("Blurb b"),
+		 default_value = "default",
+		 type = char *,
+		 flags = CONSTRUCT,
+		 export,
+		 link);
+
+	private Test:Object *objectproperty;
+	property OBJECT objectproperty (nick   = "object",
+				blurb  = "obj property",
+				object_type = Test:Object,
+				link);
+
+	private Test:Enum enum_property;
+	property ENUM enum_property (nick   = "enumprop",
+				blurb  = "enumprop",
+				enum_type = Test:Enum,
+				link);
+
+	private Some:Flags flags_property;
+	property ENUM flags_property (nick   = "flagsprop",
+				blurb  = "flagsprop",
+				flags_type = Some:Flags,
+				link);
+
 	private int j;
-	public GtkWidget * h;
+	public GObject * h;
 	public char *bleh;
 	public double array[23][18];
 	protected unsigned long int wagawaga;
@@ -99,21 +212,19 @@ class Gtk:Weird:Button from Gtk:Button {
 	 *
 	 * Returns: new object
 	 */
-	public GtkWidget * new(int j (check > 0)) {
-		GtkWidget *ret;
-		ret = GTK_WIDGET (GET_NEW);
+	public GObject * new(int j (check > 0)) {
+		GObject *ret;
+		ret = G_OBJECT (GET_NEW);
 
 		SELF(ret)->_priv->j = j;
 
 		return ret;
 	}
-	private int _blah(self, Gtk:Widget * wid (check null type),
+	private int blah(self, G:Object * wid (check null type),
 			 int h (check > 0)) onerror -1 {
-		gtk_container_add(GTK_CONTAINER(self),wid);
-
-		gtk_object_set(GTK_OBJECT(self),
-			       GTK_WEIRD_BUTTON_ARG_I(99),
-			       NULL);
+		g_object_set (G_OBJECT (self),
+			      TEST_OBJECT_PROP_I (99),
+			      NULL);
 		return h;
 	}
 	/**
@@ -126,11 +237,19 @@ class Gtk:Weird:Button from Gtk:Button {
 	 *
 	 * Returns: new object
 	 **/
-	signal last INT (POINTER, INT)
-	int bleh(self, Gtk:Widget * wid (check null type),
+	signal last STRING (POINTER, INT)
+	char * bleh(self, G:Object * wid (check null type),
 		        int h (check > 0)) {
-		return _blah(self,wid,h);
+		return self_blah(self,wid,h) > 0 ? g_strdup ("foo") : g_strdup ("bar");
 	}
+
+	private
+	char *
+	test_handler (self, GObject *w, int h, gpointer data)
+	{
+		return NULL;
+	}
+
 	/**
 	 * gtk_weird_button_bleh2:
 	 * @self: foo
@@ -141,8 +260,16 @@ class Gtk:Weird:Button from Gtk:Button {
 	 *
 	 * Returns: new object */
 	signal last INT (POINTER, INT)
-	int bleh2(self, Gtk:Widget * wid (check null type),
+	int bleh2(self, const G:Object * wid (check null type),
 		        int h (check > 0)) {
+
+		test_object_connect__bleh (self, self_test_handler, NULL);
+		self_connect__bleh (self, self_test_handler, NULL);
+		test_object_connect_after__bleh (self, self_test_handler, NULL);
+		self_connect_after__bleh (self, self_test_handler, NULL);
+		test_object_connect_data__bleh (self, self_test_handler, NULL, NULL, 0);
+		self_connect_data__bleh (self, self_test_handler, NULL, NULL, 0);
+
 		/* testing multiple marshaller support */
 		return 0;
 	}
@@ -173,23 +300,62 @@ class Gtk:Weird:Button from Gtk:Button {
 	signal first NONE (NONE)
 	void bloh(self);
 	virtual void * bah(self, int h (check > 0)) onerror NULL defreturn 0 {
-		beh(self,h);
+		self_beh(self,h);
 		return NULL;
 	}
 	virtual int beh(self, int h (check > 0));
-	override(Gtk:Container) void add(Gtk:Container * self (check null type),
+	/*override(G:Object) void add(Gtk:Container * self (check null type),
 				         Gtk:Widget * wid (check null type)) {
 		PARENT_HANDLER(self,wid);
-	}
+	}*/
 	public int consttest(self, const gchar *text, ...)
 	{
 		return 25;
 	}
+	public int consttest2(self, gchar const *text, ...)
+	{
+		return 25;
+	}
+	public int consttest3(self, G:Object const *wid (check null type))
+	{
+		return 25;
+	}
+	public int consttest4(const self)
+	{
+		return 25;
+	}
+	public int consttest5(self const)
+	{
+		return 25;
+	}
+	virtual int consttest6(const self)
+	{
+		return 25;
+	}
+	virtual int consttest7(self const)
+	{
+		return 25;
+	}
+	public int consttest8(self)
+	{
+		Self const *selfconst1, *selfconst2;
+		selfconst1 = SELF_CONST(self);
+		selfconst2 = TEST_OBJECT_CONST(self);
+		return 25;
+	}
+	public int consttest9(const self, int i, double b)
+	{
+		return 25;
+	}
+	public int consttest10(self const, int i, double b)
+	{
+		return 25;
+	}
 	signal private first NONE (NONE)
 	void googlegoogle(self)
 	{
 		puts("TEST1");
-		googlegoogle2(self);
+		self_googlegoogle2(self);
 	}
 	signal first private NONE (NONE)
 	void googlegoogle2(self)
@@ -197,7 +363,7 @@ class Gtk:Weird:Button from Gtk:Button {
 		int array[5][8][9]={{{0}}};
 		Self *foo = self;
 		puts("TEST2");
-		testprivvirtual(foo, array);
+		self_testprivvirtual(foo, array);
 	}
 	private signal first NONE (NONE)
 	void googlegoogle3(self)
@@ -209,19 +375,29 @@ class Gtk:Weird:Button from Gtk:Button {
 	{
 		puts("TEST4");
 	}
+	protected signal first NONE (NONE)
+	void googlegoogle_const1(const self)
+	{
+		puts("TEST4");
+	}
+	protected signal first NONE (NONE)
+	void googlegoogle_const2(self const)
+	{
+		puts("TEST4");
+	}
 	virtual private
 	void testprivvirtual(self, int some_array[5][8][9])
 	{
 		puts("TEST3");
-		googlegoogle(self);
+		self_googlegoogle(self);
 	}
 	private virtual
-	void testprivvirtual2(self, int some_array[5][8][9])
+	void testprivvirtual2(self, const int some_array[5][8][9])
 	{
 		/* nothing here */
 	}
 	public virtual
-	void testpublicvirtual(self, int some_array[5][8][9])
+	void testpublicvirtual(self, int const some_array[5][8][9])
 	{
 		/* nothing here */
 	}
@@ -247,28 +423,28 @@ class Gtk:Weird:Button from Gtk:Button {
 	{
 	}
 
-	override (Gtk:Widget)
-	int event(Gtk:Widget *self (check null type),
-		  GdkEvent *event (check null)) onerror FALSE
-	{
-		int ret;
-		/* some code */
-		ret = PARENT_HANDLER(self,event);
-		/* some code */
-		return ret;
-	}
-	override(Gtk:Container)
-	void
-	remove(Gtk:Container * self (check null type),
-	       Gtk:Widget * wid (check null type));
-
-	override(Gtk:Object)
-	void
-	destroy(Gtk:Object * self (check null type))
-	{
-		/* foo bar */
-		PARENT_HANDLER(self);
-	}
+//	override (Gtk:Widget)
+//	int event(Gtk:Widget *self (check null type),
+//		  GdkEvent *event (check null)) onerror FALSE
+//	{
+//		int ret;
+//		/* some code */
+//		ret = PARENT_HANDLER(self,event);
+//		/* some code */
+//		return ret;
+//	}
+//	override(Gtk:Container)
+//	void
+//	remove(Gtk:Container * self (check null type),
+//	       Gtk:Widget * wid (check null type));
+//
+//	override(Gtk:Object)
+//	void
+//	destroy(Gtk:Object * self (check null type))
+//	{
+//		/* foo bar */
+//		PARENT_HANDLER(self);
+//	}
 
 	protected
 	int foobar(self) {
@@ -276,12 +452,12 @@ class Gtk:Weird:Button from Gtk:Button {
 		return 5;
 	}
 
-	signal last NONE(CHAR,UCHAR,BOOL,INT,UINT,LONG,ULONG,FLOAT,DOUBLE,
+	signal last NONE(CHAR,UCHAR,BOOLEAN,INT,UINT,LONG,ULONG,FLOAT,DOUBLE,
 			 STRING,ENUM,FLAGS,BOXED,POINTER,OBJECT)
 	void
 	testargs(self, gchar a, guchar b, gboolean c, gint d, guint e, glong f,
 		 gulong g, gfloat h, gdouble i, gchar * j, gint k,
-		 guint l, gpointer m, gpointer o, GtkObject *p)
+		 guint l, gpointer m, gpointer o, GObject *p)
 	{
 		/* ugh, testing casting */
 	}
@@ -293,12 +469,68 @@ class Gtk:Weird:Button from Gtk:Button {
 	}
 
 	/* testing NONE */
-	signal BOOL (NONE)
+	signal BOOLEAN (NONE)
 	gboolean
 	test_none_thing (self)
 	{
 		return FALSE;
 	}
+
+	/* testing types */
+	public int t1;
+	public long int t2;
+	public int long t3;
+	public int long const t4;
+	public const int long t5;
+	public const char * const t6;
+	public char const * const t7;
+	public enum _gob__enum_t const * const t8;
+	public union _gob__union_t t9;
+	public union _gob__union_t * const * const * t10;
+	public struct _gob__struct_t * const * const * t11;
+	public const struct _gob__struct_t * const * const * t13;
+	public const enum _gob__enum_t * const * const * t14;
+	public enum _gob__enum_t t15;
+	public gchar const t16;
+	public const gchar * const t17;
+	public const gchar t18;
+
+	/* testing method with no arguments */
+	public void method_with_no_arguments (void)
+	{
+		/* FOO */
+	}
+
+	/* testing calling the above method */
+	public void foo (self) {
+		self_method_with_no_arguments ();
+	}
+
+	/* this is to test custom get_type */
+	/*public GtkType
+	get_type (void)
+	{
+		static guint type = 0;
+
+		if ( ! type) {
+			static const GtkTypeInfo info = {
+				"GtkWeirdButton",
+				sizeof (GtkWeirdButton),
+				sizeof (GtkWeirdButtonClass),
+				(GtkClassInitFunc) gtk_weird_button_class_init,
+				(GtkObjectInitFunc) gtk_weird_button_init,
+				NULL,
+				NULL,
+				(GtkClassInitFunc) NULL
+			};
+
+			type = gtk_type_unique (gtk_button_get_type(), &info);
+		}
+
+		return type;
+	}*/
+
+
 	/* testing empty statements */
 	;
 	;