X-Git-Url: http://git.draconx.ca/gitweb/gob-dx.git/blobdiff_plain/dd11885aadcfaafae2d6268c381b0aac94cbc149..928c6b8da5a3677aaaf33976a7d921a1498a61df:/src/test.gob diff --git a/src/test.gob b/src/test.gob index 98d8614..776c035 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 +#include /* 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,16 +40,63 @@ 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{ /* this should be in the header, just under bubu prototype */ +#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; } ; @@ -54,18 +107,25 @@ 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 + unrefwith g_object_unref; argument POINTER testingobj objectlink; - public Gtk:Object * testingobj2 + public Test:Object * testingobjfoo + unref { if (VAR) g_object_unref (VAR); }; + argument POINTER testingobjfoo objectlink; + + classwide int foo = 20; + argument INT foo link; + + 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; }; @@ -74,8 +134,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; @@ -94,21 +216,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; } /** @@ -121,11 +241,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 @@ -136,8 +264,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; } @@ -168,30 +304,70 @@ 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) { int array[5][8][9]={{{0}}}; + Self *foo = self; puts("TEST2"); - testprivvirtual(self,array); + self_testprivvirtual(foo, array); } private signal first NONE (NONE) void googlegoogle3(self) @@ -203,19 +379,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 */ } @@ -241,20 +427,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: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) { @@ -262,12 +456,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 */ } @@ -279,12 +473,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 */ ; ;